amulet-core 2.0a5__cp312-cp312-win_amd64.whl → 2.0a7__cp312-cp312-win_amd64.whl

amulet/collections/mapping.py.hpp

@@ -0,0 +1,199 @@
+#pragma once
+
+#include <memory>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/typing.h>
+
+#include <amulet/pybind11/types.hpp>
+#include <amulet/pybind11/type_hints.hpp>
+#include <amulet/pybind11/collections.hpp>
+#include "iterator.py.hpp"
+
+namespace py = pybind11;
+
+namespace Amulet {
+namespace collections {
+	template <typename clsT>
+	void PyMapping_repr(clsT cls) {
+		cls.def(
+			"__repr__",
+			[](py::object self) {
+				std::string repr = "{";
+				bool is_first = true;
+				for (auto it = self.begin(); it != self.end(); it++) {
+					if (is_first) {
+						is_first = false;
+					}
+					else {
+						repr += ", ";
+					}
+					repr += py::repr(*it);
+					repr += ": ";
+					repr += py::repr(self.attr("__getitem__")(*it));
+				}
+				repr += "}";
+				return repr;
+			}
+		);
+	}
+
+	template <typename KT = py::object, typename clsT>
+	void PyMapping_contains(clsT cls) {
+		cls.def(
+			"__contains__",
+			[](py::object self, Amulet::pybind11::type_hints::PyObjectCpp<KT> key) {
+				try {
+					self.attr("__getitem__")(key);
+					return true;
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						return false;
+					}
+					else {
+						throw;
+					}
+				}
+			}
+		);
+	}
+
+	template <typename KT = py::object, typename clsT>
+	void PyMapping_keys(clsT cls) {
+		py::object KeysView = py::module::import("collections.abc").attr("KeysView");
+		cls.def(
+			"keys",
+			[KeysView](py::object self) -> Amulet::pybind11::collections::KeysView<KT> { return KeysView(self); }
+		);
+	}
+
+	template <typename VT = py::object, typename clsT>
+	void PyMapping_values(clsT cls) {
+		py::object ValuesView = py::module::import("collections.abc").attr("ValuesView");
+		cls.def(
+			"values",
+			[ValuesView](py::object self) -> Amulet::pybind11::collections::ValuesView<VT> { return ValuesView(self); }
+		);
+	}
+
+	template <typename KT = py::object, typename VT = py::object, typename clsT>
+	void PyMapping_items(clsT cls) {
+		py::object ItemsView = py::module::import("collections.abc").attr("ItemsView");
+		cls.def(
+			"items",
+			[ItemsView](py::object self) -> Amulet::pybind11::collections::ItemsView<KT, VT> { return ItemsView(self); }
+		);
+	}
+
+	template <typename KT = py::object, typename VT = py::object, typename clsT>
+	void PyMapping_get(clsT cls) {
+		cls.def(
+			"get",
+			[](
+				py::object self, 
+				Amulet::pybind11::type_hints::PyObjectCpp<KT> key, 
+				py::typing::Optional<VT> default_ = py::none()
+			) -> py::typing::Optional<VT> {
+				try {
+					return self.attr("__getitem__")(key);
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						return default_;
+					}
+					else {
+						throw;
+					}
+				}
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMapping_eq(clsT cls) {
+		py::object dict = py::module::import("builtins").attr("dict");
+		py::object isinstance = py::module::import("builtins").attr("isinstance");
+		py::object NotImplemented = py::module::import("builtins").attr("NotImplemented");
+		py::object PyMapping = py::module::import("collections.abc").attr("Mapping");
+		cls.def(
+			"__eq__",
+			[
+				dict,
+				isinstance, 
+				NotImplemented,
+				PyMapping
+			](
+				py::object self, 
+				py::object other
+			) -> std::variant<bool, Amulet::pybind11::types::NotImplementedType> {
+				if (!isinstance(other, PyMapping)) {
+					return NotImplemented;
+				}
+				return dict(self.attr("items")()).equal(dict(other.attr("items")()).cast<py::dict>());
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMapping_hash(clsT cls) {
+		cls.def(
+			"__hash__",
+			[](
+				py::object self
+			) -> size_t {
+				throw py::type_error("Mapping is not hashable");
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMapping_register(clsT cls) {
+		py::module::import("collections.abc").attr("Mapping").attr("register")(cls);
+	}
+
+	class Mapping {
+	public:
+		virtual ~Mapping() {};
+		virtual py::object getitem(py::object py_key) const = 0;
+		virtual std::shared_ptr<Iterator> iter() const = 0;
+		virtual size_t size() const = 0;
+		virtual bool contains(py::object py_key) const = 0;
+	};
+
+	template <typename mapT>
+	class ConstMap : public Mapping {
+	private:
+		py::object _owner;
+		const mapT& _map;
+	public:
+		ConstMap(
+			const mapT& map,
+			py::object owner = py::none()
+		) : _owner(owner), _map(map) {}
+
+		py::object getitem(py::object py_key) const override {
+			return py::cast(_map.at(py_key.cast<typename mapT::key_type>()));
+		}
+		std::shared_ptr<Iterator> iter() const override {
+			return std::make_shared<MapIterator<mapT>>(_map, _owner);
+		}
+		size_t size() const override {
+			return _map.size();
+		}
+		bool contains(py::object py_key) const override {
+			return _map.contains(py_key.cast<typename mapT::key_type>());
+		}
+	};
+
+	template <typename mapT>
+	static py::object make_const_map(const mapT& value, py::object owner = py::none()) {
+		return py::cast(
+			static_cast<std::shared_ptr<Mapping>>(
+				std::make_shared<ConstMap<mapT>>(value, owner)
+			)
+		);
+	}
+
+}
+}

amulet/collections/mutable_mapping.py.hpp

@@ -0,0 +1,226 @@
+#pragma once
+
+#include <memory>
+
+#include <pybind11/pybind11.h>
+
+#include "mapping.py.hpp"
+
+namespace py = pybind11;
+
+namespace Amulet {
+namespace collections {
+	template <typename KT = py::object, typename VT = py::object, typename clsT>
+	void PyMutableMapping_pop(clsT cls) {
+		py::object marker = py::module::import("builtins").attr("Ellipsis");
+		cls.def(
+			"pop",
+			[marker](
+				py::object self, 
+				Amulet::pybind11::type_hints::PyObjectCpp<KT> key, 
+				Amulet::pybind11::type_hints::PyObjectCpp<VT> default_
+			) -> Amulet::pybind11::type_hints::PyObjectCpp<VT> {
+				py::object value;
+				try {
+					value = self.attr("__getitem__")(key);
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						if (default_.is(marker)) {
+							throw;
+						}
+						return default_;
+					}
+					else {
+						throw;
+					}
+				}
+				self.attr("__delitem__")(key);
+				return value;
+			},
+			py::arg("key"),
+			py::arg("default") = marker
+		);
+	}
+
+	template <typename KT = py::object, typename VT = py::object, typename clsT>
+	void PyMutableMapping_popitem(clsT cls) {
+		py::object iter = py::module::import("builtins").attr("iter");
+		py::object next = py::module::import("builtins").attr("next");
+		cls.def(
+			"popitem",
+			[iter, next](py::object self) -> std::pair<
+				Amulet::pybind11::type_hints::PyObjectCpp<KT>,
+				Amulet::pybind11::type_hints::PyObjectCpp<VT>
+			> {
+				py::object key;
+				try {
+					key = next(iter(self));
+				} 
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_StopIteration)) {
+						throw py::key_error();
+					}
+					else {
+						throw;
+					}
+				}
+				py::object value = self.attr("__getitem__")(key);
+				self.attr("__delitem__")(key);
+				return std::make_pair(key, value);
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_clear(clsT cls) {
+		cls.def(
+			"clear",
+			[](py::object self) {
+				try {
+					while (true) {
+						self.attr("popitem")();
+					}
+				}
+				catch (const py::error_already_set& e) {
+					if (!e.matches(PyExc_KeyError)) {
+						throw;
+					}
+				}
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_update(clsT cls) {
+		py::object isinstance = py::module::import("builtins").attr("isinstance");
+		py::object hasattr = py::module::import("builtins").attr("hasattr");
+		py::object PyMapping = py::module::import("collections.abc").attr("Mapping");
+		cls.def(
+			"update",
+			[
+				isinstance, 
+				hasattr, 
+				PyMapping
+			](
+				py::object self, 
+				py::object other, 
+				py::kwargs kwargs
+			) {
+				if (isinstance(other, PyMapping)) {
+					for (auto it = other.begin(); it != other.end(); it++) {
+						self.attr("__setitem__")(*it, other.attr("__getitem__")(*it));
+					}
+				}
+				else if (hasattr(other, "keys")) {
+					py::object keys = other.attr("keys")();
+					for (auto it = keys.begin(); it != keys.end(); it++) {
+						self.attr("__setitem__")(*it, other.attr("__getitem__")(*it));
+					}
+				}
+				else {
+					for (auto it = other.begin(); it != other.end(); it++) {
+						self.attr("__setitem__")(
+							*it->attr("__getitem__")(0),
+							*it->attr("__getitem__")(1)
+						);
+					}
+				}
+				py::object items = kwargs.attr("items")();
+				for (auto it = items.begin(); it != items.end(); it++) {
+					self.attr("__setitem__")(
+						*it->attr("__getitem__")(0),
+						*it->attr("__getitem__")(1)
+					);
+				}
+
+			},
+			py::arg("other") = py::tuple()
+		);
+	}
+
+	template <typename KT = py::object, typename VT = py::object, typename clsT>
+	void PyMutableMapping_setdefault(clsT cls) {
+		cls.def(
+			"setdefault",
+			[](
+				py::object self, 
+				Amulet::pybind11::type_hints::PyObjectCpp<KT> key,
+				py::typing::Optional<VT> default_ = py::none()
+			) -> py::typing::Optional<VT> {
+				try {
+					return self.attr("__getitem__")(key);
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						self.attr("__setitem__")(key, default_);
+					}
+					else {
+						throw;
+					}
+				}
+				return default_;
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_register(clsT cls) {
+		py::module::import("collections.abc").attr("MutableMapping").attr("register")(cls);
+	}
+
+	class MutableMapping : public Mapping {
+	public:
+		virtual ~MutableMapping() {};
+		virtual void setitem(py::object py_key, py::object py_value) = 0;
+		virtual void delitem(py::object py_key) = 0;
+		virtual void clear() = 0;
+	};
+
+	template <typename mapT>
+	class Map : public MutableMapping {
+	private:
+		py::object _owner;
+		mapT& _map;
+	public:
+		Map(
+			mapT& map,
+			py::object owner = py::none()
+		) : _owner(owner), _map(map) {}
+
+		py::object getitem(py::object py_key) const override {
+			return py::cast(_map.at(py_key.cast<typename mapT::key_type>()));
+		}
+		std::shared_ptr<Iterator> iter() const override {
+			return std::make_shared<MapIterator<mapT>>(_map, _owner);
+		}
+		size_t size() const override {
+			return _map.size();
+		}
+		bool contains(py::object py_key) const override {
+			return _map.contains(py_key.cast<typename mapT::key_type>());
+		}
+		void setitem(py::object py_key, py::object py_value) override {
+			_map.insert_or_assign(
+				py_key.cast<typename mapT::key_type>(),
+				py_value.cast<typename mapT::mapped_type>()
+			);
+		}
+		void delitem(py::object py_key) override {
+			_map.erase(py_key.cast<typename mapT::key_type>());
+		}
+		void clear() override {
+			_map.clear();
+		}
+	};
+
+	template <typename mapT>
+	static py::object make_map(mapT& value, py::object owner = py::none()) {
+		return py::cast(
+			static_cast<std::shared_ptr<MutableMapping>>(
+				std::make_shared<Map<mapT>>(value, owner)
+			)
+		);
+	}
+}
+}

amulet/collections/sequence.py.hpp

@@ -0,0 +1,163 @@
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+
+#include <pybind11/pybind11.h>
+#include "iterator.py.hpp"
+#include <amulet/pybind11/collections.hpp>
+
+namespace py = pybind11;
+
+namespace Amulet {
+	namespace collections {
+
+		template <typename clsT>
+		void Sequence_getitem_slice(clsT cls) {
+			cls.def(
+				"__getitem__",
+				[](py::object self, const py::slice& slice) {
+					size_t start = 0, stop = 0, step = 0, slicelength = 0;
+					if (!slice.compute(py::len(self), &start, &stop, &step, &slicelength)) {
+						throw py::error_already_set();
+					}
+					py::list out(slicelength);
+					py::object getitem = self.attr("__getitem__");
+					for (size_t i = 0; i < slicelength; ++i) {
+						out[i] = getitem(start);
+						start += step;
+					}
+					return out;
+				}
+			);
+		}
+
+		template <typename clsT>
+		void Sequence_contains(clsT cls) {
+			cls.def(
+				"__contains__",
+				[](py::object self, py::object value) {
+					py::iterator it = py::iter(self);
+					while (it != py::iterator::sentinel()) {
+						if (it->equal(value)) {
+							return true;
+						}
+						++it;
+					}
+					return false;
+				}
+			);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence_iter(clsT cls) {
+			cls.def(
+				"__iter__",
+				[](py::object self) -> Amulet::pybind11::collections::Iterator<elemT> {
+					return py::cast(
+						static_cast<std::shared_ptr<Amulet::collections::Iterator>>(
+							std::make_shared<PySequenceIterator>(self, 0, 1)
+						)
+					);
+				}
+			);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence_reversed(clsT cls) {
+			cls.def(
+				"__reversed__",
+				[](py::object self) -> Amulet::pybind11::collections::Iterator<elemT> {
+					return py::cast(
+						static_cast<std::shared_ptr<Amulet::collections::Iterator>>(
+							std::make_shared<PySequenceIterator>(self, py::len(self) - 1, -1)
+						)
+					);
+				}
+			);
+		}
+
+		template <typename clsT>
+		void Sequence_index(clsT cls) {
+			cls.def(
+				"index",
+				[](py::object self, py::object value, Py_ssize_t s_start, Py_ssize_t s_stop) {
+					size_t size = py::len(self);
+					size_t start;
+					size_t stop;
+					if (s_start < 0) {
+						start = std::max<Py_ssize_t>(0, size + s_start);
+					}
+					else {
+						start = s_start;
+					}
+					if (s_stop < 0) {
+						stop = size + s_stop;
+					}
+					else {
+						stop = s_stop;
+					}
+					py::object getitem = self.attr("__getitem__");
+					while (start < stop) {
+						py::object obj;
+						try {
+							obj = getitem(start);
+						}
+						catch (py::error_already_set& e) {
+							if (e.matches(PyExc_IndexError)) {
+								break;
+							}
+							else {
+								throw;
+							}
+						}
+
+						if (value.equal(obj)) {
+							return start;
+						}
+
+						start++;
+					}
+					throw py::value_error("");
+				},
+				py::arg("value"), py::arg("start") = 0, py::arg("stop") = std::numeric_limits<Py_ssize_t>::max()
+					);
+		}
+
+		template <typename clsT>
+		void Sequence_count(clsT cls) {
+			cls.def(
+				"count",
+				[](py::object self, py::object value) {
+					size_t count = 0;
+					size_t size = py::len(self);
+					py::object getitem = self.attr("__getitem__");
+					for (size_t i = 0; i < size; ++i) {
+						if (value.equal(getitem(i))) {
+							count++;
+						}
+					}
+					return count;
+				},
+				py::arg("value")
+					);
+		}
+
+		template <typename clsT>
+		void Sequence_register(clsT cls) {
+			py::module::import("collections.abc").attr("Sequence").attr("register")(cls);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence(clsT cls) {
+			Sequence_getitem_slice(cls);
+			Sequence_contains(cls);
+			Sequence_iter<elemT>(cls);
+			Sequence_reversed<elemT>(cls);
+			Sequence_index(cls);
+			Sequence_count(cls);
+			Sequence_register(cls);
+		}
+	}
+}

amulet/collections.pyi

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import collections.abc
 import types
 import typing
 
@@ -22,10 +23,10 @@ class Mapping:
     def __iter__(self) -> typing.Iterator: ...
     def __len__(self) -> int: ...
     def __repr__(self) -> str: ...
-    def get(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
-    def items(self) -> typing.Any: ...
-    def keys(self) -> typing.Any: ...
-    def values(self) -> typing.Any: ...
+    def get(self, arg0: typing.Any, arg1: typing.Any | None) -> typing.Any | None: ...
+    def items(self) -> collections.abc.ItemsView[typing.Any, typing.Any]: ...
+    def keys(self) -> collections.abc.KeysView[typing.Any]: ...
+    def values(self) -> collections.abc.ValuesView[typing.Any]: ...
 
 class MutableMapping(Mapping):
     def __delitem__(self, arg0: typing.Any) -> None: ...
@@ -33,5 +34,7 @@ class MutableMapping(Mapping):
     def clear(self) -> None: ...
     def pop(self, key: typing.Any, default: typing.Any = ...) -> typing.Any: ...
     def popitem(self) -> tuple[typing.Any, typing.Any]: ...
-    def setdefault(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def setdefault(
+        self, arg0: typing.Any, arg1: typing.Any | None
+    ) -> typing.Any | None: ...
     def update(self, other: typing.Any = (), **kwargs) -> None: ...

amulet/entity.py

@@ -54,28 +54,30 @@ class Entity(PlatformVersionContainer):
         self._nbt = nbt
 
     def __getstate__(self) -> tuple[tuple[str, VersionNumber], tuple[str, str, float, float, float, NamedTag]]:  # type: ignore[override]
-        return (
-            super().__getstate__(),
-            (
-                self._namespace,
-                self._base_name,
-                self._x,
-                self._y,
-                self._z,
-                self._nbt,
-            ),
-        )
+        raise NotImplementedError
+        # return (
+        #     super().__getstate__(),
+        #     (
+        #         self._namespace,
+        #         self._base_name,
+        #         self._x,
+        #         self._y,
+        #         self._z,
+        #         self._nbt,
+        #     ),
+        # )
 
     def __setstate__(self, state: tuple[tuple[str, VersionNumber], tuple[str, str, float, float, float, NamedTag]]) -> None:  # type: ignore[override]
-        super().__setstate__(state[0])
-        (
-            self._namespace,
-            self._base_name,
-            self._x,
-            self._y,
-            self._z,
-            self._nbt,
-        ) = state[1]
+        raise NotImplementedError
+        # super().__setstate__(state[0])
+        # (
+        #     self._namespace,
+        #     self._base_name,
+        #     self._x,
+        #     self._y,
+        #     self._z,
+        #     self._nbt,
+        # ) = state[1]
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Entity):

amulet/game/translate/_functions/_code_functions/_text.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, overload, Literal, TypeVar
+from typing import overload, Literal, TypeVar
 from dataclasses import dataclass, field
 from copy import deepcopy
 from enum import Enum
@@ -336,7 +336,7 @@ class RawTextComponent:
         section_text: str,
         section_parser: type[AbstractSectionParser],
         split_newline: Literal[True],
-    ) -> List[RawTextComponent]: ...
+    ) -> list[RawTextComponent]: ...
 
     @classmethod
     def from_section_text(