amulet-core 1.9.19__py3-none-any.whl → 1.9.20__py3-none-any.whl

amulet/level/formats/leveldb_world/interface/chunk/leveldb_8.py

@@ -1,180 +1,180 @@
-from __future__ import annotations
-
-from .leveldb_7 import (
-    LevelDB7Interface,
-)
-
-from typing import Tuple, Dict, Optional, TYPE_CHECKING, List
-
-import struct
-import numpy
-from numpy.typing import NDArray
-from amulet_nbt import NamedTag, CompoundTag, StringTag, IntTag, ShortTag
-
-from amulet.api.block import Block, PropertyDataTypes
-
-from amulet.utils.numpy_helpers import brute_sort_objects_no_hash
-from amulet.api.data_types import (
-    AnyNDArray,
-    VersionIdentifierTuple,
-)
-
-if TYPE_CHECKING:
-    from amulet.api.chunk.blocks import Blocks
-
-
-PackedBlockT = Tuple[Tuple[Optional[int], Block], ...]
-
-
-class LevelDB8Interface(LevelDB7Interface):
-    chunk_version = 8
-
-    def __init__(self):
-        super().__init__()
-        self._set_feature("terrain", "2fnpalette")
-
-    def _encode_subchunks(
-        self,
-        blocks: "Blocks",
-        palette: AnyNDArray,
-        bounds: Tuple[int, int],
-        max_world_version: VersionIdentifierTuple,
-    ) -> Dict[int, Optional[bytes]]:
-        # Encode sub-chunk block format 8
-        # TODO: untangle this mess. The lack of typing in numpy is just making this harder.
-        palette_list: List[PackedBlockT] = list(palette)
-        min_y = bounds[0] // 16
-        max_y = bounds[1] // 16
-        if palette_list:
-            if palette_list[0][0][0] is None:
-                air = NamedTag(
-                    CompoundTag(
-                        {
-                            "name": StringTag("minecraft:air"),
-                            "val": ShortTag(0),
-                        }
-                    )
-                )
-            else:
-                air = NamedTag(
-                    CompoundTag(
-                        {
-                            "name": StringTag("minecraft:air"),
-                            "states": CompoundTag({}),
-                            "version": IntTag(17_629_184),  # 1, 13, 0, 0
-                        }
-                    )
-                )
-
-            packed_palette: List[Tuple[NamedTag, ...]] = []
-            for index, block in enumerate(palette_list):
-                full_block: List[NamedTag] = []
-                for sub_block_version, sub_block in block:
-                    properties = sub_block.properties
-                    if sub_block_version is None:
-                        block_data = properties.get("block_data", IntTag(0))
-                        if isinstance(block_data, IntTag):
-                            block_data = block_data.py_int
-                            # if block_data >= 16:
-                            #     block_data = 0
-                        else:
-                            block_data = 0
-                        sub_block_ = NamedTag(
-                            CompoundTag(
-                                {
-                                    "name": StringTag(sub_block.namespaced_name),
-                                    "val": ShortTag(block_data),
-                                }
-                            )
-                        )
-                    else:
-                        sub_block_ = NamedTag(
-                            CompoundTag(
-                                {
-                                    "name": StringTag(sub_block.namespaced_name),
-                                    "states": CompoundTag(
-                                        {
-                                            key: val
-                                            for key, val in properties.items()
-                                            if isinstance(val, PropertyDataTypes)
-                                        }
-                                    ),
-                                    "version": IntTag(sub_block_version),
-                                }
-                            )
-                        )
-
-                    full_block.append(sub_block_)
-                packed_palette.append(tuple(full_block))
-
-            chunk = {}
-            palette_depth = numpy.array([len(block) for block in packed_palette])
-            for cy in range(min_y, max_y):
-                if cy in blocks:
-                    palette_index, sub_chunk = numpy.unique(
-                        blocks.get_sub_chunk(cy), return_inverse=True
-                    )
-                    sub_chunk_palette: List[Tuple[NamedTag, ...]] = [
-                        packed_palette[i] for i in palette_index
-                    ]
-                    sub_chunk_depth = palette_depth[palette_index].max()
-
-                    if (
-                        sub_chunk_depth == 1
-                        and len(sub_chunk_palette) == 1
-                        and sub_chunk_palette[0][0].compound.get_string("name").py_str
-                        == "minecraft:air"
-                    ):
-                        chunk[cy] = None
-                    else:
-                        # pad block_palette with air in the extra layers
-                        sub_chunk_palette_full: NDArray[NamedTag] = numpy.empty(
-                            (len(sub_chunk_palette), sub_chunk_depth), dtype=object
-                        )
-                        sub_chunk_palette_full.fill(air)
-
-                        for index, block_tuple in enumerate(sub_chunk_palette):
-                            for sub_index, block in enumerate(block_tuple):
-                                sub_chunk_palette_full[index, sub_index] = block
-                        # should now be a 2D array with an NamedTag in each element
-
-                        if max_world_version[1] >= (
-                            1,
-                            17,
-                            30,
-                        ):  # Why do I need to check against game version and not chunk version
-                            sub_chunk_bytes = [
-                                b"\x09",
-                                bytes([sub_chunk_depth]),
-                                struct.pack("b", cy),
-                            ]
-                        else:
-                            sub_chunk_bytes = [b"\x08", bytes([sub_chunk_depth])]
-                        for sub_chunk_layer_index in range(sub_chunk_depth):
-                            # TODO: sort out a way to do this quicker without brute forcing it.
-                            (
-                                sub_chunk_layer_palette,
-                                sub_chunk_remap,
-                            ) = brute_sort_objects_no_hash(
-                                sub_chunk_palette_full[:, sub_chunk_layer_index]
-                            )
-                            sub_chunk_layer = sub_chunk_remap[sub_chunk.ravel()]
-
-                            # sub_chunk_layer, sub_chunk_layer_palette = sub_chunk, sub_chunk_palette_full[:, sub_chunk_layer_index]
-                            sub_chunk_bytes.append(
-                                self._save_palette_subchunk(
-                                    sub_chunk_layer.reshape(16, 16, 16),
-                                    list(sub_chunk_layer_palette.ravel()),
-                                )
-                            )
-
-                        chunk[cy] = b"".join(sub_chunk_bytes)
-                else:
-                    chunk[cy] = None
-        else:
-            chunk = {i: None for i in range(min_y, max_y)}
-
-        return chunk
-
-
-export = LevelDB8Interface
+from __future__ import annotations
+
+from .leveldb_7 import (
+    LevelDB7Interface,
+)
+
+from typing import Tuple, Dict, Optional, TYPE_CHECKING, List
+
+import struct
+import numpy
+from numpy.typing import NDArray
+from amulet_nbt import NamedTag, CompoundTag, StringTag, IntTag, ShortTag
+
+from amulet.api.block import Block, PropertyDataTypes
+
+from amulet.utils.numpy_helpers import brute_sort_objects_no_hash
+from amulet.api.data_types import (
+    AnyNDArray,
+    VersionIdentifierTuple,
+)
+
+if TYPE_CHECKING:
+    from amulet.api.chunk.blocks import Blocks
+
+
+PackedBlockT = Tuple[Tuple[Optional[int], Block], ...]
+
+
+class LevelDB8Interface(LevelDB7Interface):
+    chunk_version = 8
+
+    def __init__(self):
+        super().__init__()
+        self._set_feature("terrain", "2fnpalette")
+
+    def _encode_subchunks(
+        self,
+        blocks: "Blocks",
+        palette: AnyNDArray,
+        bounds: Tuple[int, int],
+        max_world_version: VersionIdentifierTuple,
+    ) -> Dict[int, Optional[bytes]]:
+        # Encode sub-chunk block format 8
+        # TODO: untangle this mess. The lack of typing in numpy is just making this harder.
+        palette_list: List[PackedBlockT] = list(palette)
+        min_y = bounds[0] // 16
+        max_y = bounds[1] // 16
+        if palette_list:
+            if palette_list[0][0][0] is None:
+                air = NamedTag(
+                    CompoundTag(
+                        {
+                            "name": StringTag("minecraft:air"),
+                            "val": ShortTag(0),
+                        }
+                    )
+                )
+            else:
+                air = NamedTag(
+                    CompoundTag(
+                        {
+                            "name": StringTag("minecraft:air"),
+                            "states": CompoundTag({}),
+                            "version": IntTag(17_629_184),  # 1, 13, 0, 0
+                        }
+                    )
+                )
+
+            packed_palette: List[Tuple[NamedTag, ...]] = []
+            for index, block in enumerate(palette_list):
+                full_block: List[NamedTag] = []
+                for sub_block_version, sub_block in block:
+                    properties = sub_block.properties
+                    if sub_block_version is None:
+                        block_data = properties.get("block_data", IntTag(0))
+                        if isinstance(block_data, IntTag):
+                            block_data = block_data.py_int
+                            # if block_data >= 16:
+                            #     block_data = 0
+                        else:
+                            block_data = 0
+                        sub_block_ = NamedTag(
+                            CompoundTag(
+                                {
+                                    "name": StringTag(sub_block.namespaced_name),
+                                    "val": ShortTag(block_data),
+                                }
+                            )
+                        )
+                    else:
+                        sub_block_ = NamedTag(
+                            CompoundTag(
+                                {
+                                    "name": StringTag(sub_block.namespaced_name),
+                                    "states": CompoundTag(
+                                        {
+                                            key: val
+                                            for key, val in properties.items()
+                                            if isinstance(val, PropertyDataTypes)
+                                        }
+                                    ),
+                                    "version": IntTag(sub_block_version),
+                                }
+                            )
+                        )
+
+                    full_block.append(sub_block_)
+                packed_palette.append(tuple(full_block))
+
+            chunk = {}
+            palette_depth = numpy.array([len(block) for block in packed_palette])
+            for cy in range(min_y, max_y):
+                if cy in blocks:
+                    palette_index, sub_chunk = numpy.unique(
+                        blocks.get_sub_chunk(cy), return_inverse=True
+                    )
+                    sub_chunk_palette: List[Tuple[NamedTag, ...]] = [
+                        packed_palette[i] for i in palette_index
+                    ]
+                    sub_chunk_depth = palette_depth[palette_index].max()
+
+                    if (
+                        sub_chunk_depth == 1
+                        and len(sub_chunk_palette) == 1
+                        and sub_chunk_palette[0][0].compound.get_string("name").py_str
+                        == "minecraft:air"
+                    ):
+                        chunk[cy] = None
+                    else:
+                        # pad block_palette with air in the extra layers
+                        sub_chunk_palette_full: NDArray[NamedTag] = numpy.empty(
+                            (len(sub_chunk_palette), sub_chunk_depth), dtype=object
+                        )
+                        sub_chunk_palette_full.fill(air)
+
+                        for index, block_tuple in enumerate(sub_chunk_palette):
+                            for sub_index, block in enumerate(block_tuple):
+                                sub_chunk_palette_full[index, sub_index] = block
+                        # should now be a 2D array with an NamedTag in each element
+
+                        if max_world_version[1] >= (
+                            1,
+                            17,
+                            30,
+                        ):  # Why do I need to check against game version and not chunk version
+                            sub_chunk_bytes = [
+                                b"\x09",
+                                bytes([sub_chunk_depth]),
+                                struct.pack("b", cy),
+                            ]
+                        else:
+                            sub_chunk_bytes = [b"\x08", bytes([sub_chunk_depth])]
+                        for sub_chunk_layer_index in range(sub_chunk_depth):
+                            # TODO: sort out a way to do this quicker without brute forcing it.
+                            (
+                                sub_chunk_layer_palette,
+                                sub_chunk_remap,
+                            ) = brute_sort_objects_no_hash(
+                                sub_chunk_palette_full[:, sub_chunk_layer_index]
+                            )
+                            sub_chunk_layer = sub_chunk_remap[sub_chunk.ravel()]
+
+                            # sub_chunk_layer, sub_chunk_layer_palette = sub_chunk, sub_chunk_palette_full[:, sub_chunk_layer_index]
+                            sub_chunk_bytes.append(
+                                self._save_palette_subchunk(
+                                    sub_chunk_layer.reshape(16, 16, 16),
+                                    list(sub_chunk_layer_palette.ravel()),
+                                )
+                            )
+
+                        chunk[cy] = b"".join(sub_chunk_bytes)
+                else:
+                    chunk[cy] = None
+        else:
+            chunk = {i: None for i in range(min_y, max_y)}
+
+        return chunk
+
+
+export = LevelDB8Interface

amulet/level/formats/leveldb_world/interface/chunk/leveldb_9.py

@@ -1,18 +1,18 @@
-from __future__ import annotations
-
-from amulet.api.wrapper import EntityIDType
-from .leveldb_8 import (
-    LevelDB8Interface,
-)
-
-
-class LevelDB9Interface(LevelDB8Interface):
-    chunk_version = 9
-
-    def __init__(self):
-        super().__init__()
-        # EntityIDType.int_id is present until at least v7. Not sure which was present for v8
-        self._set_feature("entity_format", EntityIDType.namespace_str_identifier)
-
-
-export = LevelDB9Interface
+from __future__ import annotations
+
+from amulet.api.wrapper import EntityIDType
+from .leveldb_8 import (
+    LevelDB8Interface,
+)
+
+
+class LevelDB9Interface(LevelDB8Interface):
+    chunk_version = 9
+
+    def __init__(self):
+        super().__init__()
+        # EntityIDType.int_id is present until at least v7. Not sure which was present for v8
+        self._set_feature("entity_format", EntityIDType.namespace_str_identifier)
+
+
+export = LevelDB9Interface

amulet/level/formats/leveldb_world/interface/chunk/leveldb_chunk_versions.py

@@ -1,79 +1,79 @@
-from typing import Dict, Tuple
-from amulet.api.data_types import VersionNumberTuple
-
-# This is a dictionary of the first and last times each chunk version was written by a game version
-# It is used to convert the chunk version to the game version that could have saved that chunk.
-# It is also used to convert back to the chunk version when saving based on the game version.
-chunk_version_to_max_version: Dict[
-    int, Tuple[VersionNumberTuple, VersionNumberTuple]
-] = {
-    0: ((0, 9, 0, 0), (0, 9, 1, 9999)),
-    1: ((0, 9, 2, 0), (0, 9, 4, 9999)),
-    2: ((0, 9, 5, 0), (0, 16, 999, 9999)),
-    3: ((0, 17, 0, 0), (0, 17, 999, 9999)),
-    4: ((0, 18, 0, 0), (0, 18, 0, 0)),
-    5: ((0, 18, 0, 0), (1, 1, 999, 9999)),
-    6: ((1, 2, 0, 0), (1, 2, 0, 0)),
-    7: ((1, 2, 0, 0), (1, 2, 999, 9999)),
-    8: ((1, 3, 0, 0), (1, 7, 999, 9999)),
-    9: ((1, 8, 0, 0), (1, 8, 999, 9999)),
-    10: ((1, 9, 0, 0), (1, 9, 999, 9999)),
-    11: ((1, 10, 0, 0), (1, 10, 999, 9999)),
-    12: ((1, 11, 0, 0), (1, 11, 0, 9999)),
-    13: ((1, 11, 1, 0), (1, 11, 1, 9999)),
-    14: ((1, 11, 2, 0), (1, 11, 999, 999)),
-    15: ((1, 12, 0, 0), (1, 15, 999, 9999)),
-    16: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
-    17: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
-    18: ((1, 16, 0, 0), (1, 16, 0, 0)),
-    19: ((1, 16, 0, 0), (1, 16, 100, 55)),
-    20: ((1, 16, 100, 56), (1, 16, 100, 57)),
-    21: ((1, 16, 100, 58), (1, 16, 210, 0)),
-    22: ((1, 16, 210, 0), (1, 17, 999, 999)),  # caves and cliffs disabled
-    # used with experimental features
-    23: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    24: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    25: ((1, 17, 0, 0), (1, 17, 20, 999)),  # 1.17.0-20 caves and cliffs enabled
-    26: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    27: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    28: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    29: ((1, 17, 30, 0), (1, 17, 30, 999)),  # 1.17.30 caves and cliffs enabled
-    30: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    31: ((1, 17, 40, 0), (1, 17, 999, 999)),  # 1.17.40 caves and cliffs enabled
-    32: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    33: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    34: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    35: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    36: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    37: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    38: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
-    # continue without experimental gameplay
-    39: ((1, 18, 0, 0), (1, 18, 29, 999)),
-    40: ((1, 18, 30, 0), (999, 999, 999, 999)),
-}  # TODO: fill this list with the actual last game version number each chunk version was last used in
-
-
-def chunk_to_game_version(
-    max_game_version: VersionNumberTuple, chunk_version: int
-) -> VersionNumberTuple:
-    """Find the game version to use based on the chunk version."""
-    return min(chunk_version_to_max_version[chunk_version][1], max_game_version)
-
-
-def game_to_chunk_version(max_game_version: VersionNumberTuple, cnc=False) -> int:
-    """Get the chunk version that should be used for the given game version number."""
-    # The comparison can fail if they are no the same length
-    max_game_version = (max_game_version + (0,) * (4 - len(max_game_version)))[:4]
-    cnc = cnc or max_game_version >= (1, 18, 0)
-    for chunk_version, (first, last) in chunk_version_to_max_version.items():
-        if (
-            first <= max_game_version <= last  # if the version is in the range
-            and cnc
-            == (
-                chunk_version > 22
-            )  # and it is in the correct range (caves and cliffs or not)
-        ):
-            return chunk_version
-
-    # If all else fails return the minimum we support
-    return 6
+from typing import Dict, Tuple
+from amulet.api.data_types import VersionNumberTuple
+
+# This is a dictionary of the first and last times each chunk version was written by a game version
+# It is used to convert the chunk version to the game version that could have saved that chunk.
+# It is also used to convert back to the chunk version when saving based on the game version.
+chunk_version_to_max_version: Dict[
+    int, Tuple[VersionNumberTuple, VersionNumberTuple]
+] = {
+    0: ((0, 9, 0, 0), (0, 9, 1, 9999)),
+    1: ((0, 9, 2, 0), (0, 9, 4, 9999)),
+    2: ((0, 9, 5, 0), (0, 16, 999, 9999)),
+    3: ((0, 17, 0, 0), (0, 17, 999, 9999)),
+    4: ((0, 18, 0, 0), (0, 18, 0, 0)),
+    5: ((0, 18, 0, 0), (1, 1, 999, 9999)),
+    6: ((1, 2, 0, 0), (1, 2, 0, 0)),
+    7: ((1, 2, 0, 0), (1, 2, 999, 9999)),
+    8: ((1, 3, 0, 0), (1, 7, 999, 9999)),
+    9: ((1, 8, 0, 0), (1, 8, 999, 9999)),
+    10: ((1, 9, 0, 0), (1, 9, 999, 9999)),
+    11: ((1, 10, 0, 0), (1, 10, 999, 9999)),
+    12: ((1, 11, 0, 0), (1, 11, 0, 9999)),
+    13: ((1, 11, 1, 0), (1, 11, 1, 9999)),
+    14: ((1, 11, 2, 0), (1, 11, 999, 999)),
+    15: ((1, 12, 0, 0), (1, 15, 999, 9999)),
+    16: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
+    17: ((1, 15, 999, 9999), (1, 15, 999, 9999)),
+    18: ((1, 16, 0, 0), (1, 16, 0, 0)),
+    19: ((1, 16, 0, 0), (1, 16, 100, 55)),
+    20: ((1, 16, 100, 56), (1, 16, 100, 57)),
+    21: ((1, 16, 100, 58), (1, 16, 210, 0)),
+    22: ((1, 16, 210, 0), (1, 17, 999, 999)),  # caves and cliffs disabled
+    # used with experimental features
+    23: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    24: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    25: ((1, 17, 0, 0), (1, 17, 20, 999)),  # 1.17.0-20 caves and cliffs enabled
+    26: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    27: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    28: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    29: ((1, 17, 30, 0), (1, 17, 30, 999)),  # 1.17.30 caves and cliffs enabled
+    30: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    31: ((1, 17, 40, 0), (1, 17, 999, 999)),  # 1.17.40 caves and cliffs enabled
+    32: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    33: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    34: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    35: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    36: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    37: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    38: ((1, 17, 0, 0), (1, 17, 0, 0)),  # ?
+    # continue without experimental gameplay
+    39: ((1, 18, 0, 0), (1, 18, 29, 999)),
+    40: ((1, 18, 30, 0), (999, 999, 999, 999)),
+}  # TODO: fill this list with the actual last game version number each chunk version was last used in
+
+
+def chunk_to_game_version(
+    max_game_version: VersionNumberTuple, chunk_version: int
+) -> VersionNumberTuple:
+    """Find the game version to use based on the chunk version."""
+    return min(chunk_version_to_max_version[chunk_version][1], max_game_version)
+
+
+def game_to_chunk_version(max_game_version: VersionNumberTuple, cnc=False) -> int:
+    """Get the chunk version that should be used for the given game version number."""
+    # The comparison can fail if they are no the same length
+    max_game_version = (max_game_version + (0,) * (4 - len(max_game_version)))[:4]
+    cnc = cnc or max_game_version >= (1, 18, 0)
+    for chunk_version, (first, last) in chunk_version_to_max_version.items():
+        if (
+            first <= max_game_version <= last  # if the version is in the range
+            and cnc
+            == (
+                chunk_version > 22
+            )  # and it is in the correct range (caves and cliffs or not)
+        ):
+            return chunk_version
+
+    # If all else fails return the minimum we support
+    return 6

amulet/level/formats/mcstructure/__init__.py

@@ -1,3 +1,3 @@
-from .format_wrapper import MCStructureFormatWrapper
-
-export = MCStructureFormatWrapper
+from .format_wrapper import MCStructureFormatWrapper
+
+export = MCStructureFormatWrapper