amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp312-cp312-win_amd64.whl

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,63 +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

amulet/resource_pack/abc/resource_pack_manager.py

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

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

amulet/resource_pack/java/download_resources.py

@@ -1,212 +0,0 @@
-import os
-import shutil
-import zipfile
-import json
-from urllib.request import urlopen, Request
-import io
-from typing import Generator, TypeVar, Any, Optional
-import logging
-
-from amulet.resource_pack import JavaResourcePack
-
-T = TypeVar("T")
-
-log = logging.getLogger(__name__)
-
-launcher_manifest: Optional[dict] = None
-INCLUDE_SNAPSHOT = False
-
-
-def get_launcher_manifest() -> dict:
-    global launcher_manifest
-    if launcher_manifest is None:
-        log.info("Downloading java launcher manifest file.")
-        with urlopen(
-            "https://launchermeta.mojang.com/mc/game/version_manifest.json", timeout=20
-        ) as manifest:
-            launcher_manifest = json.load(manifest)
-        log.info("Finished downloading java launcher manifest file.")
-    return launcher_manifest
-
-
-def generator_unpacker(gen: Generator[Any, Any, T]) -> T:
-    try:
-        while True:
-            next(gen)
-    except StopIteration as e:
-        return e.value  # type: ignore
-
-
-def get_latest() -> JavaResourcePack:
-    return generator_unpacker(get_latest_iter())
-
-
-def get_latest_iter() -> Generator[float, None, JavaResourcePack]:
-    """Download the latest resource pack if required.
-
-    :return: The loaded Java resource pack.
-    :raises:
-        Exception: If the
-    """
-    vanilla_rp_path = os.path.join(
-        os.environ["CACHE_DIR"], "resource_packs", "java", "vanilla"
-    )
-    try:
-        if INCLUDE_SNAPSHOT:
-            new_version = get_launcher_manifest()["latest"]["snapshot"]
-        else:
-            new_version = get_launcher_manifest()["latest"]["release"]
-    except Exception as e:
-        if os.path.isdir(vanilla_rp_path):
-            log.error(
-                "Could not download the launcher manifest. The resource pack seems to be present so using that."
-            )
-        else:
-            raise e
-    else:
-        has_new_pack = False
-        if os.path.isfile(os.path.join(vanilla_rp_path, "version")):
-            with open(os.path.join(vanilla_rp_path, "version")) as f:
-                old_version = f.read()
-            has_new_pack = old_version == new_version
-
-        if not has_new_pack:
-            yield from _remove_and_download_iter(vanilla_rp_path, new_version)
-    return JavaResourcePack(vanilla_rp_path)
-
-
-_java_vanilla_fix: Optional[JavaResourcePack] = None
-_java_vanilla_latest: Optional[JavaResourcePack] = None
-
-
-def get_java_vanilla_fix() -> JavaResourcePack:
-    global _java_vanilla_fix
-    if _java_vanilla_fix is None:
-        _java_vanilla_fix = JavaResourcePack(
-            os.path.join(os.path.dirname(__file__), "java_vanilla_fix")
-        )
-    return _java_vanilla_fix
-
-
-def get_java_vanilla_latest() -> JavaResourcePack:
-    global _java_vanilla_latest
-    if _java_vanilla_latest is None:
-        _java_vanilla_latest = get_latest()
-    return _java_vanilla_latest
-
-
-def get_java_vanilla_latest_iter() -> Generator[float, None, JavaResourcePack]:
-    global _java_vanilla_latest
-    if _java_vanilla_latest is None:
-        _java_vanilla_latest = yield from get_latest_iter()
-    return _java_vanilla_latest
-
-
-def _remove_and_download(path: str, version: str) -> None:
-    for _ in _remove_and_download_iter(path, version):
-        pass
-
-
-def _remove_and_download_iter(path: str, version: str) -> Generator[float, None, None]:
-    # try downloading the new resources to a temporary location
-    temp_path = os.path.join(os.path.dirname(path), "_temp_")
-    # clear the temporary location
-    if os.path.isfile(temp_path):
-        os.remove(temp_path)
-    elif os.path.isdir(temp_path):
-        shutil.rmtree(temp_path, ignore_errors=True)
-
-    yield from download_resources_iter(temp_path, version)
-    if os.path.isdir(path):
-        shutil.rmtree(path, ignore_errors=True)
-
-    shutil.move(temp_path, path)
-
-    with open(os.path.join(path, "version"), "w") as f:
-        f.write(version)
-
-
-def download_with_retry(
-    url: str, chunk_size: int = 4096, attempts: int = 5
-) -> Generator[float, None, bytes]:
-    content_length_found = 0
-    content = []
-
-    for _ in range(attempts):
-        request = Request(url, headers={"Range": f"bytes={content_length_found}-"})
-        with urlopen(request, timeout=20) as response:
-            content_length = int(response.headers["content-length"].strip())
-            while content_length_found < content_length:
-                chunk = response.read(chunk_size)
-                if not chunk:
-                    break
-                content.append(chunk)
-                content_length_found += len(chunk)
-                yield min(1.0, content_length_found / content_length)
-        if content_length == content_length_found:
-            break
-    else:
-        raise RuntimeError(f"Failed to download")
-    return b"".join(content)
-
-
-def download_resources(path: str, version: str) -> None:
-    generator_unpacker(download_resources_iter(path, version))
-
-
-def download_resources_iter(
-    path: str, version: str, chunk_size: int = 4096
-) -> Generator[float, None, None]:
-    log.info(f"Downloading Java resource pack for version {version}")
-    version_url = next(
-        (v["url"] for v in get_launcher_manifest()["versions"] if v["id"] == version),
-        None,
-    )
-    if version_url is None:
-        raise Exception(f"Could not find Java resource pack for version {version}.")
-
-    try:
-        with urlopen(version_url, timeout=20) as vm:
-            version_manifest = json.load(vm)
-        version_client_url = version_manifest["downloads"]["client"]["url"]
-
-        downloader = download_with_retry(version_client_url)
-        try:
-            while True:
-                yield next(downloader) / 2
-        except StopIteration as e:
-            data = e.value
-
-        client = zipfile.ZipFile(io.BytesIO(data))
-        paths: list[str] = [
-            fpath for fpath in client.namelist() if fpath.startswith("assets/")
-        ]
-        path_count = len(paths)
-        for path_index, fpath in enumerate(paths):
-            if not path_index % 30:
-                yield path_index / (path_count * 2) + 0.5
-            if fpath.endswith("/"):
-                continue
-            os.makedirs(
-                os.path.dirname(os.path.abspath(os.path.join(path, fpath))),
-                exist_ok=True,
-            )
-            client.extract(fpath, path)
-        if "pack.mcmeta" in client.namelist():
-            client.extract("pack.mcmeta", path)
-        else:
-            # TODO: work out proper version support for this
-            with open(os.path.join(path, "pack.mcmeta"), "w") as f:
-                f.write(
-                    '{"pack": {"description": "The default data for Minecraft","pack_format": 7}}'
-                )
-        if "pack.png" in client.namelist():
-            client.extract("pack.png", path)
-
-    except Exception as e:
-        log.error(
-            f"Failed to download and extract the Java resource pack for version {version}.",
-            exc_info=True,
-        )
-        raise e
-    log.info(f"Finished downloading Java resource pack for version {version}")

amulet/resource_pack/java/resource_pack.py

@@ -1,44 +0,0 @@
-import os
-import json
-
-from amulet.resource_pack.abc import BaseResourcePack
-
-
-class JavaResourcePack(BaseResourcePack):
-    """A class to hold the bare bones information about the resource pack.
-    Holds the pack format, description and if the pack is valid.
-    This information can be used in a viewer to display the packs to the user."""
-
-    def __init__(self, resource_pack_path: str):
-        super().__init__(resource_pack_path)
-        meta_path = os.path.join(resource_pack_path, "pack.mcmeta")
-        self._pack_format = 0
-        if os.path.isfile(meta_path):
-            try:
-                with open(meta_path) as f:
-                    pack_mcmeta = json.load(f)
-            except json.JSONDecodeError:
-                pass
-            else:
-                if "pack" in pack_mcmeta:
-                    if "description" in pack_mcmeta["pack"]:
-                        self._pack_description = str(pack_mcmeta["pack"]["description"])
-                    if "pack_format" in pack_mcmeta["pack"]:
-                        self._pack_format = pack_mcmeta["pack"]["pack_format"]
-                        self._valid_pack = True
-
-        pack_icon_path = os.path.join(resource_pack_path, "pack.png")
-        if os.path.isfile(pack_icon_path):
-            self._pack_icon = pack_icon_path
-
-    @staticmethod
-    def is_valid(pack_path: str) -> bool:
-        return os.path.isfile(os.path.join(pack_path, "pack.mcmeta"))
-
-    def __repr__(self) -> str:
-        return f"JavaResourcePack({self._root_dir})"
-
-    @property
-    def pack_format(self) -> int:
-        """int - pack format number"""
-        return self._pack_format