amulet-core 2.0a7__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp311-cp311-win_amd64.whl

amulet/palette/biome_palette.hpp

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <stdexcept>
-
-#include <amulet/version.hpp>
-#include <amulet/biome.hpp>
-
-
-namespace Amulet {
-
-	struct PtrLess {
-		bool operator()(std::shared_ptr<Biome> lhs, std::shared_ptr<Biome> rhs) const {
-			return *lhs < *rhs;
-		}
-	};
-
-	class BiomePalette : public VersionRangeContainer {
-	private:
-		std::vector<std::shared_ptr<Biome>> _index_to_biome;
-		std::map<
-			const std::shared_ptr<Biome>,
-			size_t,
-			PtrLess
-		> _biome_to_index;
-	public:
-		const std::vector<std::shared_ptr<Biome>>& get_biomes() const { return _index_to_biome; }
-
-		BiomePalette(std::shared_ptr<VersionRange> version_range) :
-			VersionRangeContainer(version_range),
-			_index_to_biome(),
-			_biome_to_index() {}
-
-		bool operator==(const BiomePalette& other) const {
-			if (size() != other.size()) {
-				return false;
-			}
-			for (size_t i = 0; i < size(); i++) {
-				if (*_index_to_biome[i] != *other._index_to_biome[i]) {
-					return false;
-				}
-			}
-			return true;
-		};
-
-		size_t size() const { return _index_to_biome.size(); }
-
-		std::shared_ptr<Biome> index_to_biome(size_t index) const {
-			return _index_to_biome[index];
-		};
-
-		size_t biome_to_index(std::shared_ptr<Biome> biome) {
-			auto it = _biome_to_index.find(biome);
-			if (it != _biome_to_index.end()) {
-				return it->second;
-			}
-			const auto& version_range = get_version_range();
-			if (!version_range->contains(biome->get_platform(), *biome->get_version())) {
-				throw std::invalid_argument(
-					"Biome(\"" +
-					biome->get_platform() +
-					"\", " +
-					biome->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_biome.size();
-			_index_to_biome.push_back(biome);
-			_biome_to_index[biome] = index;
-			return index;
-		};
-
-		bool contains_biome(std::shared_ptr<Biome> biome) const {
-			return _biome_to_index.contains(biome);
-		}
-	};
-
-}

amulet/palette/block_palette.cpp

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

@@ -1,93 +0,0 @@
-#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/player.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from amulet.data_types import DimensionId
-
-LOCAL_PLAYER = "~local_player"
-
-
-class Player:
-    def __init__(
-        self,
-        player_id: str,
-        dimension_id: DimensionId,
-        location: tuple[float, float, float],
-        rotation: tuple[float, float],
-    ) -> None:
-        """
-        Creates a new instance of :class:`Player` with the given UUID, location, and rotation
-
-        :param player_id: The ID of the player
-        :param location: The location of the player in world coordinates
-        :param rotation: The rotation of the player
-        :param dimension_id: The dimension the player is in
-        """
-        super().__init__()
-        assert isinstance(player_id, str)
-        assert (
-            isinstance(location, tuple)
-            and len(location) == 3
-            and all(isinstance(f, float) for f in location)
-        )
-        assert (
-            isinstance(rotation, tuple)
-            and len(rotation) == 2
-            and all(isinstance(f, float) for f in rotation)
-        )
-        self._player_id = player_id
-        self._location = location
-        self._rotation = rotation
-        self._dimension_id = dimension_id
-
-    def __repr__(self) -> str:
-        return f"Player({self.player_id}, {self.dimension_id}, {self.location}, {self.rotation})"
-
-    @property
-    def player_id(self) -> str:
-        """The player's ID"""
-        return self._player_id
-
-    @property
-    def location(self) -> tuple[float, float, float]:
-        """The current location of the player in the world"""
-        return self._location
-
-    @property
-    def rotation(self) -> tuple[float, float]:
-        """The current rotation of the player in the world"""
-        return self._rotation
-
-    @property
-    def dimension_id(self) -> DimensionId:
-        """The current dimension the player is in"""
-        return self._dimension_id

amulet/pybind11/collections.hpp

@@ -1,118 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-namespace Amulet {
-	namespace pybind11 {
-		namespace collections {
-			template <typename T>
-			class Iterator : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Iterator, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename T>
-			class Sequence : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Sequence, object, PyObject_Type)
-				using object::object;
-			};
-		
-			template <typename K, typename V>
-			class Mapping : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Mapping, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename K, typename V>
-			class MutableMapping : public py::object {
-				PYBIND11_OBJECT_DEFAULT(MutableMapping, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename K>
-			class KeysView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(KeysView, object, PyObject_Type)
-					using object::object;
-			};
-
-			template <typename V>
-			class ValuesView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(ValuesView, object, PyObject_Type)
-					using object::object;
-			};
-
-			template <typename K, typename V>
-			class ItemsView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(ItemsView, object, PyObject_Type)
-					using object::object;
-			};
-		}
-	}
-}
-
-namespace pybind11 {
-	namespace detail {
-		template <typename T>
-		struct handle_type_name<Amulet::pybind11::collections::Iterator<T>> {
-			static constexpr auto name =
-				const_name("collections.abc.Iterator[") +
-				make_caster<T>::name +
-				const_name("]");
-		};
-
-		template <typename T>
-		struct handle_type_name<Amulet::pybind11::collections::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<Amulet::pybind11::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("]");
-		};
-
-		template <typename K, typename V>
-		struct handle_type_name<Amulet::pybind11::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("]");
-		};
-
-		template <typename K>
-		struct handle_type_name<Amulet::pybind11::collections::KeysView<K>> {
-			static constexpr auto name =
-				const_name("collections.abc.KeysView[") +
-				make_caster<K>::name +
-				const_name("]");
-		};
-
-		template <typename V>
-		struct handle_type_name<Amulet::pybind11::collections::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<Amulet::pybind11::collections::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/numpy.hpp

@@ -1,26 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-#include <pybind11/numpy.h>
-
-namespace py = pybind11;
-
-namespace Amulet {
-	namespace pybind11 {
-		namespace numpy {
-			template <typename T, int ExtraFlags = py::array::forcecast>
-			class array_t : public py::array_t<T, ExtraFlags> {
-				using py::array_t<T, ExtraFlags>::array_t;
-			};
-		}
-	}
-}
-
-namespace pybind11 {
-	namespace detail {
-		template <typename T, int Flags>
-		struct handle_type_name<Amulet::pybind11::numpy::array_t<T, Flags>> {
-			static constexpr auto name
-				= const_name("numpy.typing.NDArray[") + npy_format_descriptor<T>::name + const_name("]");
-		};
-	}
-}

amulet/pybind11/py_module.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <string>
-#include <functional>
-#include <filesystem>
-#include <map>
-#include <utility>
-
-#include <pybind11/pybind11.h>
-#include <amulet/pybind11/typing.hpp>
-
-namespace py = pybind11;
-
-namespace pybind11 {
-	inline void def_package_path(py::module m_parent, py::module m, std::string name) {
-		py::list paths;
-		py::list parent_paths = m_parent.attr("__path__").cast<py::list>();
-		for (auto py_path : parent_paths) {
-			if (py::isinstance<py::str>(py_path)) {
-				std::string path = py_path.cast<std::string>();
-				path.push_back(std::filesystem::path::preferred_separator);
-				path.append(name);
-				paths.append(py::cast(path));
-			}
-		}
-		m.attr("__path__") = paths;
-	}
-
-	inline module def_subpackage(py::module m_parent, std::string name) {
-		auto m = m_parent.def_submodule(name.c_str());
-		def_package_path(m_parent, m, name);
-		return m;
-	}
-}

amulet/pybind11/type_hints.hpp

@@ -1,51 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-#include <pybind11/detail/descr.h>
-#include <vector>
-
-namespace py = pybind11;
-
-namespace Amulet {
-	namespace pybind11 {
-		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>;
-		}
-
-		// Type hint for a native python object.
-		namespace type_hints {
-			template <detail::FixedString T>
-			class PyObjectStr : public py::object {
-				PYBIND11_OBJECT_DEFAULT(PyObjectStr, object, PyObject_Type)
-					using object::object;
-			};
-
-			template <typename cppT>
-			class PyObjectCpp : public py::object {
-				PYBIND11_OBJECT_DEFAULT(PyObjectCpp, object, PyObject_Type)
-					using object::object;
-			};
-		}
-	}
-}
-
-namespace pybind11 {
-	namespace detail {
-		template <Amulet::pybind11::detail::FixedString T>
-		struct handle_type_name<Amulet::pybind11::type_hints::PyObjectStr<T>> {
-			static constexpr auto name = pybind11::detail::const_name(T.buf);
-		};
-
-		template <typename cppT>
-		struct handle_type_name<Amulet::pybind11::type_hints::PyObjectCpp<cppT>> {
-			static constexpr auto name = make_caster<cppT>::name;
-		};
-	}
-}

amulet/pybind11/types.hpp

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

amulet/pybind11/typing.hpp

@@ -1,7 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-#include <vector>
-
-namespace pybind11 {
-
-}

amulet/resource_pack/__init__.py

@@ -1,62 +0,0 @@
-from typing import Iterable, Union
-
-from amulet.resource_pack.abc import (
-    BaseResourcePack,
-    BaseResourcePackManager,
-)
-from amulet.resource_pack.java import (
-    JavaResourcePack,
-    JavaResourcePackManager,
-)
-from amulet.resource_pack.bedrock import (
-    BedrockResourcePack,
-    BedrockResourcePackManager,
-)
-from .unknown_resource_pack import UnknownResourcePack
-
-
-def load_resource_pack(resource_pack_path: str) -> BaseResourcePack:
-    if JavaResourcePack.is_valid(resource_pack_path):
-        return JavaResourcePack(resource_pack_path)
-    elif BedrockResourcePack.is_valid(resource_pack_path):
-        return BedrockResourcePack(resource_pack_path)
-    else:
-        return UnknownResourcePack(resource_pack_path)
-
-
-def load_resource_pack_manager(
-    resource_packs: Iterable[Union[str, BaseResourcePack]], load: bool = True
-) -> BaseResourcePackManager:
-    resource_packs_out: list[BaseResourcePack] = []
-    for resource_pack in resource_packs:
-        if isinstance(resource_pack, str):
-            resource_pack = load_resource_pack(resource_pack)
-        if (
-            not isinstance(resource_pack, UnknownResourcePack)
-            and resource_pack.valid_pack
-        ):
-            if resource_packs_out:
-                if isinstance(resource_pack, resource_packs_out[0].__class__):
-                    resource_packs_out.append(resource_pack)
-            else:
-                resource_packs_out.append(resource_pack)
-
-    resource_packs = resource_packs_out
-    if resource_packs:
-        if isinstance(resource_packs[0], JavaResourcePack):
-            return JavaResourcePackManager(
-                [pack for pack in resource_packs if isinstance(pack, JavaResourcePack)],
-                load,
-            )
-        elif isinstance(resource_packs[0], BedrockResourcePack):
-            return BedrockResourcePackManager(
-                [
-                    pack
-                    for pack in resource_packs
-                    if isinstance(pack, BedrockResourcePack)
-                ],
-                load,
-            )
-
-    raise NotImplementedError
-    # return UnknownResourcePackManager()

amulet/resource_pack/abc/__init__.py

@@ -1,2 +0,0 @@
-from .resource_pack import BaseResourcePack
-from .resource_pack_manager import BaseResourcePackManager

amulet/resource_pack/abc/resource_pack.py

@@ -1,38 +0,0 @@
-from amulet.img import missing_pack_icon_path
-
-
-class BaseResourcePack:
-    """The base class that all resource packs must inherit from. Defines the base api."""
-
-    def __init__(self, root_dir: str):
-        self._valid_pack = False
-        self._root_dir = root_dir
-        self._pack_description = ""
-        self._pack_icon = missing_pack_icon_path
-
-    def __repr__(self) -> str:
-        raise NotImplementedError
-
-    @staticmethod
-    def is_valid(pack_path: str) -> bool:
-        raise NotImplementedError
-
-    @property
-    def valid_pack(self) -> bool:
-        """bool - does the pack meet the minimum requirements to be a resource pack"""
-        return self._valid_pack
-
-    @property
-    def root_dir(self) -> str:
-        """str - the root directory of the pack"""
-        return self._root_dir
-
-    @property
-    def pack_description(self) -> str:
-        """str - the description as described in the pack"""
-        return self._pack_description
-
-    @property
-    def pack_icon(self) -> str:
-        """str - path to the pack icon"""
-        return self._pack_icon