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

amulet/resource_pack/bedrock/resource_pack_manager.py

@@ -1,361 +0,0 @@
-import os
-import json
-from typing import Union, Iterable, Generator, Optional, TypedDict, Literal, Any
-from PIL import Image
-import numpy
-
-from amulet.block import Block
-from amulet.utils import comment_json
-from amulet.resource_pack import BaseResourcePackManager
-from amulet.resource_pack.bedrock import BedrockResourcePack
-from amulet.mesh.block.block_mesh import BlockMesh
-from .blockshapes import BlockShapeClasses
-
-
-class NumericalProperty(TypedDict):
-    name: str
-    type: Union[Literal["byte"], Literal["int"]]
-    value: int
-
-
-class StrProperty(TypedDict):
-    name: str
-    type: Literal["string"]
-    value: str
-
-
-class StateDict(TypedDict):
-    name: str
-    data: int
-    states: list[Union[NumericalProperty, StrProperty]]
-
-
-class BlockPaletteDict(TypedDict):
-    blocks: list[StateDict]
-
-
-def _load_data() -> tuple[
-    dict[str, str],
-    dict[
-        str,
-        tuple[
-            tuple[tuple[str, Union[int, str]], ...],
-            dict[tuple[Union[str, int], ...], int],
-        ],
-    ],
-]:
-    with open(os.path.join(os.path.dirname(__file__), "blockshapes.json")) as f:
-        _block_shapes: dict[str, str] = comment_json.load(f)  # type: ignore
-
-    _aux_values: dict[
-        str,
-        tuple[
-            tuple[tuple[str, Union[int, str]], ...],
-            dict[tuple[Union[str, int], ...], int],
-        ],
-    ] = {}
-    with open(os.path.join(os.path.dirname(__file__), "block_palette.json")) as f:
-        _block_palette: BlockPaletteDict = comment_json.load(f)  # type: ignore
-    for block in _block_palette["blocks"]:
-        data = block["data"]
-        name = block["name"]
-        if name not in _aux_values:
-            _aux_values[name] = (
-                tuple((state["name"], state["value"]) for state in block["states"]),
-                {},
-            )
-        _aux_values[name][1][tuple(state["value"] for state in block["states"])] = data
-
-    return _block_shapes, _aux_values
-
-
-BlockShapes, AuxValues = _load_data()
-
-
-def get_aux_value(block: Block) -> int:
-    name = block.namespaced_name
-    if name in AuxValues:
-        property_names, aux_map = AuxValues[name]
-        properties = block.properties
-        key = tuple(
-            (
-                properties[property_name].py_data
-                if property_name in properties
-                else default
-            )
-            for property_name, default in property_names
-        )
-        return aux_map.get(key, 0)
-    else:
-        return 0
-
-
-class BedrockResourcePackManager(BaseResourcePackManager):
-    """A class to load and handle the data from the packs.
-    Packs are given as a list with the later packs overwriting the earlier ones."""
-
-    def __init__(
-        self,
-        resource_packs: Union[BedrockResourcePack, Iterable[BedrockResourcePack]],
-        load: bool = True,
-    ) -> None:
-        super().__init__()
-        self._block_shapes: dict[str, str] = {}  # block string to block shape
-        self._blocks: dict[str, Union[dict[str, str], str, None]] = (
-            {}
-        )  # block string to short texture ids
-        self._terrain_texture: dict[str, tuple[str, ...]] = (
-            {}
-        )  # texture ids to list of relative paths. Each relates to a different data value.
-        self._textures: dict[str, str] = {}  # relative path to texture path
-        self._all_textures = None
-
-        self._texture_is_transparent: dict[str, tuple[float, bool]] = {}
-
-        if isinstance(resource_packs, (list, tuple)):
-            self._packs = [
-                rp for rp in resource_packs if isinstance(rp, BedrockResourcePack)
-            ]
-        elif isinstance(resource_packs, BedrockResourcePack):
-            self._packs = [resource_packs]
-        else:
-            raise Exception(f"Invalid format {resource_packs}")
-        if load:
-            for _ in self.reload():
-                pass
-
-    def _unload(self) -> None:
-        """Clear all loaded resources."""
-        super()._unload()
-        self._block_shapes.clear()
-        self._blocks.clear()
-        self._terrain_texture.clear()
-        self._textures.clear()
-        self._all_textures = None
-
-    def _check_texture(self, texture_path: str) -> str:
-        if os.path.isfile(texture_path + ".png"):
-            texture_path += ".png"
-        elif os.path.isfile(texture_path + ".tga"):
-            texture_path += ".tga"
-        else:
-            texture_path = self.missing_no
-        if (
-            os.stat(texture_path).st_mtime
-            != self._texture_is_transparent.get(texture_path, [0])[0]
-        ):
-            im: Image.Image = Image.open(texture_path)
-            if im.mode == "RGBA":
-                alpha = numpy.array(im.getchannel("A").getdata())
-                texture_is_transparent = bool(numpy.any(alpha != 255))
-            else:
-                texture_is_transparent = False
-
-            self._texture_is_transparent[texture_path] = (
-                os.stat(texture_path).st_mtime,
-                bool(texture_is_transparent),
-            )
-        return texture_path
-
-    def _load_iter(self) -> Generator[float, None, None]:
-        self._block_shapes.update(BlockShapes)  # add the default block shapes
-
-        transparency_cache_path = os.path.join(
-            os.environ["CACHE_DIR"],
-            "resource_packs",
-            "bedrock",
-            "transparency_cache.json",
-        )
-        self._load_transparency_cache(transparency_cache_path)
-
-        self._textures["missing_no"] = self._check_texture("missing")
-
-        pack_count = len(self._packs)
-
-        for pack_index, pack in enumerate(self._packs):
-            pack_progress = pack_index / pack_count
-            yield pack_progress
-
-            if pack.valid_pack:
-                terrain_texture_path = os.path.join(
-                    pack.root_dir, "textures", "terrain_texture.json"
-                )
-                if os.path.isfile(terrain_texture_path):
-                    try:
-                        with open(terrain_texture_path) as f:
-                            terrain_texture = comment_json.load(f)
-                    except json.JSONDecodeError:
-                        pass
-                    else:
-                        if (
-                            isinstance(terrain_texture, dict)
-                            and "texture_data" in terrain_texture
-                            and isinstance(terrain_texture["texture_data"], dict)
-                        ):
-                            sub_progress = pack_progress
-                            image_count = len(terrain_texture["texture_data"])
-
-                            def get_texture(_relative_path: Any) -> str:
-                                if isinstance(_relative_path, dict):
-                                    _relative_path = _relative_path.get(
-                                        "path", "misssingno"
-                                    )
-                                    assert isinstance(_relative_path, str)
-                                if isinstance(_relative_path, str):
-                                    full_path = self._check_texture(
-                                        os.path.join(pack.root_dir, _relative_path)
-                                    )
-                                    if _relative_path in self._textures:
-                                        if full_path != self.missing_no:
-                                            self._textures[_relative_path] = full_path
-                                    else:
-                                        self._textures[_relative_path] = full_path
-                                else:
-                                    raise TypeError
-                                return _relative_path
-
-                            for image_index, (texture_id, data) in enumerate(
-                                terrain_texture["texture_data"].items()
-                            ):
-                                if (
-                                    isinstance(texture_id, str)
-                                    and isinstance(data, dict)
-                                    and "textures" in data
-                                ):
-                                    texture_data = data["textures"]
-                                    if isinstance(texture_data, list):
-                                        self._terrain_texture[texture_id] = tuple(
-                                            get_texture(relative_path)
-                                            for relative_path in texture_data
-                                        )
-                                    else:
-                                        self._terrain_texture[texture_id] = (
-                                            get_texture(texture_data),
-                                        ) * 16
-                                yield sub_progress + image_index / (
-                                    image_count * pack_count * 2
-                                )
-                sub_progress = pack_progress + 1 / (pack_count * 2)
-                yield sub_progress
-                blocks_path = os.path.join(pack.root_dir, "blocks.json")
-                if os.path.isfile(blocks_path):
-                    try:
-                        with open(blocks_path) as f:
-                            blocks = comment_json.load(f)
-                    except json.JSONDecodeError:
-                        pass
-                    else:
-                        if isinstance(blocks, dict):
-                            model_count = len(blocks)
-                            for model_index, (block_id, data) in enumerate(
-                                blocks.items()
-                            ):
-                                if isinstance(block_id, str) and isinstance(data, dict):
-                                    if ":" not in block_id:
-                                        block_id = "minecraft:" + block_id
-                                    textures = data.get("textures")
-                                    if textures is None or isinstance(textures, str):
-                                        self._blocks[block_id] = textures
-                                    elif isinstance(textures, dict) and all(
-                                        isinstance(v, str) for v in textures.values()
-                                    ):
-                                        self._blocks[block_id] = textures  # type: ignore  # TODO: improve this with TypeGuard
-                                    else:
-                                        raise TypeError
-
-                                yield sub_progress + (model_index) / (
-                                    model_count * pack_count * 2
-                                )
-            yield pack_progress + 1
-
-        os.makedirs(os.path.dirname(transparency_cache_path), exist_ok=True)
-        with open(transparency_cache_path, "w") as f:
-            json.dump(self._texture_is_transparent, f)
-
-    @property
-    def textures(self) -> tuple[str, ...]:
-        """Returns a tuple of all the texture paths in the resource pack."""
-        return tuple(self._textures.values())
-
-    def get_texture_path(self, namespace: Optional[str], relative_path: str) -> str:
-        """Get the absolute texture path from the namespace and relative path pair"""
-        if relative_path in self._textures:
-            return self._textures[relative_path]
-        else:
-            return self.missing_no
-
-    def _get_model(self, block: Block) -> BlockMesh:
-        block_shape = self._block_shapes.get(block.namespaced_name, "cube")
-
-        if block_shape in BlockShapeClasses:
-            block_shape_class = BlockShapeClasses[block_shape]
-        else:
-            block_shape_class = BlockShapeClasses["cube"]
-
-        if not block_shape_class.is_valid(block):
-            block_shape_class = BlockShapeClasses["cube"]
-
-        texture_index = block_shape_class.texture_index(block, get_aux_value(block))
-
-        if block.namespaced_name in self._blocks:
-            texture_id = self._blocks[block.namespaced_name]
-            if isinstance(texture_id, str):
-                up = down = north = east = south = west = self._get_texture(
-                    texture_id, texture_index
-                )
-                transparent = (self._texture_is_transparent[up][1],) * 6
-
-            elif isinstance(texture_id, dict):
-                down = self._get_texture(
-                    texture_id.get("down", "missing"), texture_index
-                )
-                up = self._get_texture(texture_id.get("up", "missing"), texture_index)
-
-                if "side" in texture_id:
-                    north = east = south = west = self._get_texture(
-                        texture_id.get("side", "missing"), texture_index
-                    )
-                    transparent = (
-                        self._texture_is_transparent[down][1],
-                        self._texture_is_transparent[up][1],
-                    ) + (self._texture_is_transparent[north][1],) * 4
-                else:
-                    north = self._get_texture(
-                        texture_id.get("north", "missing"), texture_index
-                    )
-                    east = self._get_texture(
-                        texture_id.get("east", "missing"), texture_index
-                    )
-                    south = self._get_texture(
-                        texture_id.get("south", "missing"), texture_index
-                    )
-                    west = self._get_texture(
-                        texture_id.get("west", "missing"), texture_index
-                    )
-                    transparent = (
-                        self._texture_is_transparent[down][1],
-                        self._texture_is_transparent[up][1],
-                        self._texture_is_transparent[north][1],
-                        self._texture_is_transparent[east][1],
-                        self._texture_is_transparent[south][1],
-                        self._texture_is_transparent[west][1],
-                    )
-            else:
-                up = down = north = east = south = west = self._get_texture(
-                    "missing", texture_index
-                )
-                transparent = (self._texture_is_transparent[up][1],) * 6
-
-            return block_shape_class.get_block_model(
-                block, down, up, north, east, south, west, transparent
-            )
-
-        return self.missing_block
-
-    def _get_texture(self, texture_id: str, index: int) -> str:
-        texture = self.missing_no
-        if texture_id in self._terrain_texture:
-            texture_list = self._terrain_texture[texture_id]
-            if len(texture_list) > index:
-                texture = self.get_texture_path(None, texture_list[index])
-        return texture

amulet/resource_pack/bedrock/sort_blockshapes.py

@@ -1,15 +0,0 @@
-import os
-import json
-
-
-def main() -> None:
-    with open(os.path.join(os.path.dirname(__file__), "blockshapes.json")) as f:
-        shapes = json.load(f)
-        shapes_tuple = tuple(sorted(shapes.items(), key=lambda i: (i[1], i[0])))
-        shapes2 = dict(shapes_tuple)
-    with open(os.path.join(os.path.dirname(__file__), "blockshapes.json"), "w") as f:
-        json.dump(shapes2, f, indent=4)
-
-
-if __name__ == "__main__":
-    main()

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}")