amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1a2.post250529084738__cp311-cp311-win_amd64.whl

amulet/collections/mutable_mapping.py.hpp

@@ -1,226 +0,0 @@
-#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

@@ -1,163 +0,0 @@
-#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,40 +0,0 @@
-from __future__ import annotations
-
-import collections.abc
-import types
-import typing
-
-__all__ = ["Holder", "Iterator", "Mapping", "MutableMapping"]
-
-class Holder:
-    """
-    A utility class for keeping smart pointers alive.
-    """
-
-class Iterator:
-    def __iter__(self: typing.Iterator) -> typing.Iterator: ...
-    def __next__(self: typing.Iterator) -> typing.Any: ...
-
-class Mapping:
-    def __contains__(self, arg0: typing.Any) -> bool: ...
-    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
-    def __getitem__(self, arg0: typing.Any) -> typing.Any: ...
-    def __hash__(self) -> int: ...
-    def __iter__(self) -> typing.Iterator: ...
-    def __len__(self) -> int: ...
-    def __repr__(self) -> str: ...
-    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: ...
-    def __setitem__(self, arg0: typing.Any, arg1: typing.Any) -> None: ...
-    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 | None
-    ) -> typing.Any | None: ...
-    def update(self, other: typing.Any = (), **kwargs) -> None: ...

amulet/data_types.py

@@ -1,29 +0,0 @@
-from typing import TypeAlias
-import numpy
-
-#: The type for a dimension identifier
-DimensionId: TypeAlias = str
-
-#: The data type for the x and z coordinates of a region file. Note these are no the same as block coordinates.
-RegionCoordinates: TypeAlias = tuple[int, int]
-
-#: The data type for the x and z coordinate of a chunk. Note these are no the same as block coordinates.
-ChunkCoordinates: TypeAlias = tuple[int, int]
-
-#: The data type for the x, y and z coordinates of a sub-chunk within the world. Note these are no the same as block coordinates.
-SubChunkCoordinates: TypeAlias = tuple[int, int, int]
-
-#: The data type for the x, y and z location of a block within the world.
-BlockCoordinates: TypeAlias = tuple[int, int, int]
-
-#: The data type for the x, y and z location of a block within the world in the form of a numpy array.
-BlockCoordinatesArray: TypeAlias = numpy.ndarray  # NDArray[(3, ), int]
-
-#: The data type for the x, y and z location of a point within the world.
-PointCoordinates: TypeAlias = tuple[float, float, float]
-
-#: The data type for the x, y and z location of a point within the world in the form of a numpy array.
-PointCoordinatesArray: TypeAlias = numpy.ndarray  # NDArray[(3, ), numpy.float]
-
-#: The data type for a tuple containing three floats. Use :data:`PointCoordinates` for x, y, z float coordinates.
-FloatTriplet: TypeAlias = tuple[float, float, float]

amulet/entity.py

@@ -1,182 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-from amulet_nbt import NamedTag
-from amulet.version import PlatformVersionContainer, VersionNumber
-from amulet.data_types import PointCoordinates
-
-
-class Entity(PlatformVersionContainer):
-    """
-    A class to contain all the data to define an Entity.
-    """
-
-    __slots__ = (
-        "_namespace",
-        "_base_name",
-        "_x",
-        "_y",
-        "_z",
-        "_nbt",
-    )
-
-    def __init__(
-        self,
-        platform: str,
-        version: VersionNumber,
-        namespace: str,
-        base_name: str,
-        x: float,
-        y: float,
-        z: float,
-        nbt: NamedTag,
-    ) -> None:
-        """
-        Constructs a :class:`Entity` instance.
-
-        :param platform: The platform the entity is defined in.
-        :param version: The version the entity is defined in.
-        :param namespace: The namespace of the entity eg "minecraft"
-        :param base_name: The base name of the entity eg "creeper"
-        :param x: The x coordinate of the entity
-        :param y: The y coordinate of the entity
-        :param z: The z coordinate of the entity
-        :param nbt: The NBT stored with the entity
-        """
-        super().__init__(platform, version)
-        self._namespace = str(namespace)
-        self._base_name = str(base_name)
-        self._x = float(x)
-        self._y = float(y)
-        self._z = float(z)
-        if not isinstance(nbt, NamedTag):
-            raise TypeError(f"nbt must be an NamedTag. Got {nbt}")
-        self._nbt = nbt
-
-    def __getstate__(self) -> tuple[tuple[str, VersionNumber], tuple[str, str, float, float, float, NamedTag]]:  # type: ignore[override]
-        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]
-        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):
-            return NotImplemented
-        return self.__getstate__() == other.__getstate__()
-
-    def __hash__(self) -> int:
-        return id(self)
-
-    def __repr__(self) -> str:
-        return f"Entity({self.platform!r}, {self.version!r}, {self._namespace!r}, {self._base_name!r}, {self._x}, {self._y}, {self._z}, {self._nbt!r})"
-
-    @property
-    def namespaced_name(self) -> str:
-        """
-        The namespace:base_name of the entity represented by the object (eg: `minecraft:creeper`)
-
-        If the given namespace is an empty string it will just return the base name.
-
-        :return: namespace:base_name of the entity
-        """
-        return f"{self._namespace}:{self._base_name}"
-
-    @property
-    def namespace(self) -> str:
-        """
-        The namespace of the entity represented by the Entity object (eg: `minecraft`)
-
-        :return: The namespace of the entity
-        """
-        return self._namespace
-
-    @namespace.setter
-    def namespace(self, value: str) -> None:
-        self._namespace = value
-
-    @property
-    def base_name(self) -> str:
-        """
-        The base name of the entity represented by the Entity object (eg: `creeper`, `pig`)
-
-        :return: The base name of the entity
-        """
-        return self._base_name
-
-    @base_name.setter
-    def base_name(self, value: str) -> None:
-        self._base_name = value
-
-    @property
-    def x(self) -> float:
-        """The x location of the Entity."""
-        return self._x
-
-    @x.setter
-    def x(self, value: float) -> None:
-        self._x = float(value)
-
-    @property
-    def y(self) -> float:
-        """The y location of the Entity."""
-        return self._y
-
-    @y.setter
-    def y(self, value: float) -> None:
-        self._y = float(value)
-
-    @property
-    def z(self) -> float:
-        """The z location of the Entity."""
-        return self._z
-
-    @z.setter
-    def z(self, value: float) -> None:
-        self._z = float(value)
-
-    @property
-    def location(self) -> PointCoordinates:
-        """The location of the Entity."""
-        return self._x, self._y, self._z
-
-    @location.setter
-    def location(self, location: PointCoordinates) -> None:
-        self.x, self.y, self.z = location
-
-    @property
-    def nbt(self) -> NamedTag:
-        """
-        The NBT behind the object
-
-        :getter: Get the NBT data stored in the object
-        :setter: Set the NBT data stored in the object
-
-        :return: A NamedTag
-        """
-        return self._nbt
-
-    @nbt.setter
-    def nbt(self, value: NamedTag) -> None:
-        if not isinstance(value, NamedTag):
-            raise TypeError
-        self._nbt = value

amulet/game/__init__.py

@@ -1,7 +0,0 @@
-"""
-A module to store data about the game including state enumerations and translations between different game versions.
-"""
-
-from ._game import game_platforms, game_versions, get_game_version
-from .java import JavaGameVersion
-from .bedrock import BedrockGameVersion