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

amulet/pybind11/collections.hpp

@@ -1,51 +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)
+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<collections::Iterator<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("]");
 		};
-	}
-	
-	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>> {
+		struct handle_type_name<Amulet::pybind11::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>> {
+		struct handle_type_name<Amulet::pybind11::collections::Mapping<K, V>> {
 			static constexpr auto name =
 				const_name("collections.abc.Mapping[") +
 				make_caster<K>::name +
@@ -53,20 +78,37 @@ namespace pybind11 {
 				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;
+		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("]");
 		};
-	}
-	namespace detail {
+
+		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<collections::MutableMapping<K, V>> {
+		struct handle_type_name<Amulet::pybind11::collections::ItemsView<K, V>> {
 			static constexpr auto name =
-				const_name("collections.abc.MutableMapping[") +
+				const_name("collections.abc.ItemsView[") +
 				make_caster<K>::name +
 				const_name(", ")
 				+ make_caster<V>::name +

amulet/pybind11/numpy.hpp

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

@@ -7,63 +7,28 @@
 #include <utility>
 
 #include <pybind11/pybind11.h>
+#include <amulet/pybind11/typing.hpp>
 
 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));
+	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.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);
+		}
+		m.attr("__path__") = paths;
 	}
 
-	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);
+	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

@@ -0,0 +1,51 @@
+#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,16 +1,24 @@
 #pragma once
 #include <pybind11/pybind11.h>
 
-namespace pybind11 {
-	namespace types {
-		class NotImplementedType : public object {
-			PYBIND11_OBJECT_DEFAULT(NotImplementedType, object, PyObject_Type)
+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<types::NotImplementedType> {
+		struct handle_type_name<Amulet::pybind11::types::NotImplementedType> {
 			static constexpr auto name = const_name("types.NotImplementedType");
 		};
 	}

amulet/pybind11/typing.hpp

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

amulet/resource_pack/__init__.py

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

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

amulet/resource_pack/abc/resource_pack.py

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

amulet/resource_pack/abc/resource_pack_manager.py

@@ -0,0 +1,85 @@
+from typing import Optional, Iterator, TypeVar, Generic
+import json
+
+from amulet.block import Block, BlockStack
+from amulet.mesh.block import BlockMesh, merge_block_meshes, get_missing_block
+from amulet.resource_pack.abc.resource_pack import BaseResourcePack
+from amulet.img import missing_no_icon_path
+
+PackT = TypeVar("PackT", bound=BaseResourcePack)
+
+
+class BaseResourcePackManager(Generic[PackT]):
+    """The base class that all resource pack managers must inherit from. Defines the base api."""
+
+    def __init__(self) -> None:
+        self._packs: list[PackT] = []
+        self._missing_block: Optional[BlockMesh] = None
+        self._texture_is_transparent: dict[str, tuple[float, bool]] = {}
+        self._cached_models: dict[BlockStack, BlockMesh] = {}
+
+    @property
+    def pack_paths(self) -> list[str]:
+        return [pack.root_dir for pack in self._packs]
+
+    def _unload(self) -> None:
+        """Clear all loaded resources."""
+        self._texture_is_transparent.clear()
+        self._cached_models.clear()
+
+    def _load_transparency_cache(self, path: str) -> None:
+        try:
+            with open(path) as f:
+                self._texture_is_transparent = json.load(f)
+        except:
+            pass
+
+    def _load_iter(self) -> Iterator[float]:
+        """Load resources."""
+        raise NotImplementedError
+
+    def reload(self) -> Iterator[float]:
+        """Unload and reload resources"""
+        self._unload()
+        yield from self._load_iter()
+
+    @property
+    def missing_no(self) -> str:
+        """The path to the missing_no image"""
+        return missing_no_icon_path
+
+    @property
+    def missing_block(self) -> BlockMesh:
+        if self._missing_block is None:
+            self._missing_block = get_missing_block(self)
+        return self._missing_block
+
+    @property
+    def textures(self) -> tuple[str, ...]:
+        """Returns a tuple of all the texture paths in the resource pack."""
+        raise NotImplementedError
+
+    def get_texture_path(self, namespace: Optional[str], relative_path: str) -> str:
+        """Get the absolute texture path from the namespace and relative path pair"""
+        raise NotImplementedError
+
+    def get_block_model(self, block_stack: BlockStack) -> BlockMesh:
+        """Get a model for a block state.
+        The block should already be in the resource pack format"""
+        if block_stack not in self._cached_models:
+            if len(block_stack) == 1:
+                self._cached_models[block_stack] = self._get_model(
+                    block_stack.base_block
+                )
+            else:
+                self._cached_models[block_stack] = merge_block_meshes(
+                    (self._get_model(block_stack.base_block),)
+                    + tuple(
+                        self._get_model(block_) for block_ in block_stack.extra_blocks
+                    )
+                )
+
+        return self._cached_models[block_stack]
+
+    def _get_model(self, block: Block) -> BlockMesh:
+        raise NotImplementedError

amulet/resource_pack/java/__init__.py

@@ -0,0 +1,2 @@
+from .resource_pack import JavaResourcePack
+from .resource_pack_manager import JavaResourcePackManager