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

amulet/level/formats/sponge_schem/interface.py

@@ -1,118 +1,118 @@
-from typing import TYPE_CHECKING, Any, Tuple
-import numpy
-
-from amulet.api.wrapper import Interface, EntityIDType, EntityCoordType
-from amulet.api.chunk import Chunk
-from amulet.api.selection import SelectionBox
-from amulet.api.data_types import AnyNDArray, VersionIdentifierType, VersionNumberAny
-from amulet.level.loader import Translators
-from amulet.api.block import Block
-from .chunk import SpongeSchemChunk
-
-from amulet_nbt import NamedTag
-
-if TYPE_CHECKING:
-    from amulet.api.wrapper import Translator
-    from PyMCTranslate import TranslationManager
-
-
-class SpongeSchemInterface(Interface):
-    _entity_id_type = EntityIDType.namespace_str_Id
-    _entity_coord_type = EntityCoordType.Pos_list_double
-    _block_entity_id_type = EntityIDType.namespace_str_Id
-    _block_entity_coord_type = EntityCoordType.Pos_array_int
-
-    def is_valid(self, key: Tuple) -> bool:
-        return True
-
-    def decode(
-        self, cx: int, cz: int, data: SpongeSchemChunk
-    ) -> Tuple["Chunk", AnyNDArray]:
-        """
-        Create an amulet.api.chunk.Chunk object from raw data given by the format
-        :param cx: chunk x coordinate
-        :param cz: chunk z coordinate
-        :param data: Raw chunk data provided by the format.
-        :return: Chunk object in version-specific format, along with the block_palette for that chunk.
-        """
-        palette = numpy.empty(len(data.palette) + 1, dtype=object)
-        palette[0] = Block(namespace="minecraft", base_name="air")
-        palette[1:] = data.palette[:]
-
-        chunk = Chunk(cx, cz)
-        box = data.selection.create_moved_box((cx * 16, 0, cz * 16), subtract=True)
-        chunk.blocks[box.slice] = data.blocks + 1
-        for tag in data.block_entities:
-            block_entity = self._decode_block_entity(
-                NamedTag(tag), self._block_entity_id_type, self._block_entity_coord_type
-            )
-            if block_entity is not None:
-                chunk.block_entities.insert(block_entity)
-        for tag in data.entities:
-            entity = self._decode_entity(
-                NamedTag(tag), self._block_entity_id_type, self._block_entity_coord_type
-            )
-            if entity is not None:
-                chunk.entities.append(entity)
-
-        return chunk, palette
-
-    def encode(
-        self,
-        chunk: "Chunk",
-        palette: AnyNDArray,
-        max_world_version: VersionIdentifierType,
-        box: SelectionBox,
-    ) -> SpongeSchemChunk:
-        """
-        Take a version-specific chunk and encode it to raw data for the format to store.
-        :param chunk: The already translated version-specfic chunk to encode.
-        :param palette: The block_palette the ids in the chunk correspond to.
-        :type palette: numpy.ndarray[Block]
-        :param max_world_version: The key to use to find the encoder.
-        :param box: The volume of the chunk to pack.
-        :return: Raw data to be stored by the Format.
-        """
-        entities = []
-        for entity in chunk.entities:
-            if entity.location in box:
-                entities.append(
-                    self._encode_entity(
-                        entity, self._entity_id_type, self._entity_coord_type
-                    ).compound
-                )
-        block_entities = []
-        for block_entity in chunk.block_entities:
-            if block_entity.location in box:
-                block_entities.append(
-                    self._encode_block_entity(
-                        block_entity,
-                        self._block_entity_id_type,
-                        self._block_entity_coord_type,
-                    ).compound
-                )
-
-        slices = box.create_moved_box(
-            (chunk.cx * 16, 0, chunk.cz * 16), subtract=True
-        ).slice
-
-        return SpongeSchemChunk(
-            box,
-            numpy.asarray(chunk.blocks[slices]),
-            palette.copy(),
-            block_entities,
-            entities,
-        )
-
-    def get_translator(
-        self,
-        max_world_version: Tuple[str, int],
-        data: Any = None,
-        translation_manager: "TranslationManager" = None,
-    ) -> Tuple["Translator", VersionNumberAny]:
-        platform, version_number = max_world_version
-        if platform != "java":
-            raise ValueError("Platform must be java")
-        version = translation_manager.get_version(platform, version_number)
-        version_number = version.data_version
-        return Translators.get((platform, version_number)), version_number
+from typing import TYPE_CHECKING, Any, Tuple
+import numpy
+
+from amulet.api.wrapper import Interface, EntityIDType, EntityCoordType
+from amulet.api.chunk import Chunk
+from amulet.api.selection import SelectionBox
+from amulet.api.data_types import AnyNDArray, VersionIdentifierType, VersionNumberAny
+from amulet.level.loader import Translators
+from amulet.api.block import Block
+from .chunk import SpongeSchemChunk
+
+from amulet_nbt import NamedTag
+
+if TYPE_CHECKING:
+    from amulet.api.wrapper import Translator
+    from PyMCTranslate import TranslationManager
+
+
+class SpongeSchemInterface(Interface):
+    _entity_id_type = EntityIDType.namespace_str_Id
+    _entity_coord_type = EntityCoordType.Pos_list_double
+    _block_entity_id_type = EntityIDType.namespace_str_Id
+    _block_entity_coord_type = EntityCoordType.Pos_array_int
+
+    def is_valid(self, key: Tuple) -> bool:
+        return True
+
+    def decode(
+        self, cx: int, cz: int, data: SpongeSchemChunk
+    ) -> Tuple["Chunk", AnyNDArray]:
+        """
+        Create an amulet.api.chunk.Chunk object from raw data given by the format
+        :param cx: chunk x coordinate
+        :param cz: chunk z coordinate
+        :param data: Raw chunk data provided by the format.
+        :return: Chunk object in version-specific format, along with the block_palette for that chunk.
+        """
+        palette = numpy.empty(len(data.palette) + 1, dtype=object)
+        palette[0] = Block(namespace="minecraft", base_name="air")
+        palette[1:] = data.palette[:]
+
+        chunk = Chunk(cx, cz)
+        box = data.selection.create_moved_box((cx * 16, 0, cz * 16), subtract=True)
+        chunk.blocks[box.slice] = data.blocks + 1
+        for tag in data.block_entities:
+            block_entity = self._decode_block_entity(
+                NamedTag(tag), self._block_entity_id_type, self._block_entity_coord_type
+            )
+            if block_entity is not None:
+                chunk.block_entities.insert(block_entity)
+        for tag in data.entities:
+            entity = self._decode_entity(
+                NamedTag(tag), self._block_entity_id_type, self._block_entity_coord_type
+            )
+            if entity is not None:
+                chunk.entities.append(entity)
+
+        return chunk, palette
+
+    def encode(
+        self,
+        chunk: "Chunk",
+        palette: AnyNDArray,
+        max_world_version: VersionIdentifierType,
+        box: SelectionBox,
+    ) -> SpongeSchemChunk:
+        """
+        Take a version-specific chunk and encode it to raw data for the format to store.
+        :param chunk: The already translated version-specfic chunk to encode.
+        :param palette: The block_palette the ids in the chunk correspond to.
+        :type palette: numpy.ndarray[Block]
+        :param max_world_version: The key to use to find the encoder.
+        :param box: The volume of the chunk to pack.
+        :return: Raw data to be stored by the Format.
+        """
+        entities = []
+        for entity in chunk.entities:
+            if entity.location in box:
+                entities.append(
+                    self._encode_entity(
+                        entity, self._entity_id_type, self._entity_coord_type
+                    ).compound
+                )
+        block_entities = []
+        for block_entity in chunk.block_entities:
+            if block_entity.location in box:
+                block_entities.append(
+                    self._encode_block_entity(
+                        block_entity,
+                        self._block_entity_id_type,
+                        self._block_entity_coord_type,
+                    ).compound
+                )
+
+        slices = box.create_moved_box(
+            (chunk.cx * 16, 0, chunk.cz * 16), subtract=True
+        ).slice
+
+        return SpongeSchemChunk(
+            box,
+            numpy.asarray(chunk.blocks[slices]),
+            palette.copy(),
+            block_entities,
+            entities,
+        )
+
+    def get_translator(
+        self,
+        max_world_version: Tuple[str, int],
+        data: Any = None,
+        translation_manager: "TranslationManager" = None,
+    ) -> Tuple["Translator", VersionNumberAny]:
+        platform, version_number = max_world_version
+        if platform != "java":
+            raise ValueError("Platform must be java")
+        version = translation_manager.get_version(platform, version_number)
+        version_number = version.data_version
+        return Translators.get((platform, version_number)), version_number

amulet/level/formats/sponge_schem/varint/__init__.py

@@ -1 +1 @@
-from .varint import decode_stream, decode_bytes, decode_byte_array, encode_array
+from .varint import decode_stream, decode_bytes, decode_byte_array, encode_array

amulet/level/formats/sponge_schem/varint/varint.py

@@ -1,87 +1,87 @@
-"""Varint encoder/decoder
-
-varints are a common encoding for variable length integer data, used in
-libraries such as sqlite, protobuf, v8, and more.
-
-Here's a quick and dirty module to help avoid reimplementing the same thing
-over and over again.
-
-With modifications to allow reading and writing an array of varints.
-"""
-
-from io import BytesIO
-from typing import List, Iterable
-
-
-def _read_byte(stream: BytesIO) -> int:
-    """Read a byte from the file (as an integer)
-
-    :param stream: The stream to read the byte from.
-    :return: The integer value of the byte.
-    :raises:
-        EOFError: if the stream ends while reading bytes.
-    """
-    c = stream.read(1)
-    if not c:
-        raise EOFError("Unexpected EOF while reading bytes")
-    return ord(c)
-
-
-def decode_stream_one(stream: BytesIO) -> int:
-    """Read a varint from `stream`"""
-    shift = 0
-    result = 0
-    while True:
-        i = _read_byte(stream)
-        result |= (i & 0x7F) << shift
-        shift += 7
-        if not (i & 0x80):
-            break
-    return result
-
-
-def decode_bytes_one(buf: bytes):
-    """Read a varint from `buf` bytes"""
-    return decode_stream_one(BytesIO(buf))
-
-
-def decode_stream(stream: BytesIO) -> List[int]:
-    """Read varint(s) from `stream` until the stream has been exhausted."""
-    start = stream.tell()
-    end = stream.seek(0, 2)
-    stream.seek(start)
-
-    result = []
-    while stream.tell() < end:
-        result.append(decode_stream_one(stream))
-    return result
-
-
-def decode_bytes(buf: bytes) -> List[int]:
-    """Read varint(s) from `buf` bytes until all the bytes have been exhausted."""
-    return decode_stream(BytesIO(buf))
-
-
-def decode_byte_array(buf: Iterable[int]) -> List[int]:
-    """Read varint(s) from an iterable of ints until the iterable has been exhausted.
-    All ints must be in range(0, 256)"""
-    return decode_bytes(bytes(buf))
-
-
-def encode(number: int):
-    """Pack `number` into varint bytes"""
-    buf = []
-    while True:
-        towrite = number & 0x7F
-        number >>= 7
-        if number:
-            buf.append(bytes((towrite | 0x80,)))
-        else:
-            buf.append(bytes((towrite,)))
-            break
-    return b"".join(buf)
-
-
-def encode_array(array: Iterable[int]) -> bytes:
-    """Pack an array of integers into a sequence of packed varint(s)."""
-    return b"".join(encode(n) for n in array)
+"""Varint encoder/decoder
+
+varints are a common encoding for variable length integer data, used in
+libraries such as sqlite, protobuf, v8, and more.
+
+Here's a quick and dirty module to help avoid reimplementing the same thing
+over and over again.
+
+With modifications to allow reading and writing an array of varints.
+"""
+
+from io import BytesIO
+from typing import List, Iterable
+
+
+def _read_byte(stream: BytesIO) -> int:
+    """Read a byte from the file (as an integer)
+
+    :param stream: The stream to read the byte from.
+    :return: The integer value of the byte.
+    :raises:
+        EOFError: if the stream ends while reading bytes.
+    """
+    c = stream.read(1)
+    if not c:
+        raise EOFError("Unexpected EOF while reading bytes")
+    return ord(c)
+
+
+def decode_stream_one(stream: BytesIO) -> int:
+    """Read a varint from `stream`"""
+    shift = 0
+    result = 0
+    while True:
+        i = _read_byte(stream)
+        result |= (i & 0x7F) << shift
+        shift += 7
+        if not (i & 0x80):
+            break
+    return result
+
+
+def decode_bytes_one(buf: bytes):
+    """Read a varint from `buf` bytes"""
+    return decode_stream_one(BytesIO(buf))
+
+
+def decode_stream(stream: BytesIO) -> List[int]:
+    """Read varint(s) from `stream` until the stream has been exhausted."""
+    start = stream.tell()
+    end = stream.seek(0, 2)
+    stream.seek(start)
+
+    result = []
+    while stream.tell() < end:
+        result.append(decode_stream_one(stream))
+    return result
+
+
+def decode_bytes(buf: bytes) -> List[int]:
+    """Read varint(s) from `buf` bytes until all the bytes have been exhausted."""
+    return decode_stream(BytesIO(buf))
+
+
+def decode_byte_array(buf: Iterable[int]) -> List[int]:
+    """Read varint(s) from an iterable of ints until the iterable has been exhausted.
+    All ints must be in range(0, 256)"""
+    return decode_bytes(bytes(buf))
+
+
+def encode(number: int):
+    """Pack `number` into varint bytes"""
+    buf = []
+    while True:
+        towrite = number & 0x7F
+        number >>= 7
+        if number:
+            buf.append(bytes((towrite | 0x80,)))
+        else:
+            buf.append(bytes((towrite,)))
+            break
+    return b"".join(buf)
+
+
+def encode_array(array: Iterable[int]) -> bytes:
+    """Pack an array of integers into a sequence of packed varint(s)."""
+    return b"".join(encode(n) for n in array)

amulet/level/interfaces/chunk/anvil/anvil_0.py

@@ -1,72 +1,72 @@
-from __future__ import annotations
-
-from typing import Tuple, TYPE_CHECKING
-
-from amulet_nbt import IntTag
-
-import amulet
-from .base_anvil_interface import ChunkPathType, ChunkDataType
-from .anvil_na import AnvilNAInterface as ParentInterface
-
-if TYPE_CHECKING:
-    from amulet.api.chunk import Chunk
-
-
-class Anvil0Interface(ParentInterface):
-    """
-    Added the DataVersion tag
-    Note that this has not been tested before 1.12
-    """
-
-    V = None
-    RegionDataVersion: ChunkPathType = (
-        "region",
-        [("DataVersion", IntTag)],
-        IntTag,
-    )
-
-    def __init__(self):
-        super().__init__()
-        self._unregister_decoder(self._decode_v_tag)
-        self._unregister_encoder(self._encode_v_tag)
-
-        self._register_post_decoder(self._post_decode_data_version)
-
-    @staticmethod
-    def minor_is_valid(key: int):
-        return 0 <= key < 1444
-
-    def _post_decode_data_version(
-        self, chunk: Chunk, data: ChunkDataType, floor_cy: int, height_cy: int
-    ):
-        # all versioned data must get removed from data
-        self.get_layer_obj(data, self.RegionDataVersion, pop_last=True)
-
-    def _decode_entities(
-        self, chunk: Chunk, data: ChunkDataType, floor_cy: int, height_cy: int
-    ):
-        ents = self._decode_entity_list(
-            self.get_layer_obj(data, self.Entities, pop_last=True)
-        )
-        if amulet.entity_support:
-            chunk.entities = ents
-        else:
-            chunk._native_entities.extend(ents)
-            chunk._native_version = (
-                "java",
-                self.get_layer_obj(data, self.RegionDataVersion).py_int,
-            )
-
-    def _init_encode(
-        self,
-        chunk: Chunk,
-        max_world_version: Tuple[str, int],
-        floor_cy: int,
-        height_cy: int,
-    ) -> ChunkDataType:
-        data = super()._init_encode(chunk, max_world_version, floor_cy, height_cy)
-        self.set_layer_obj(data, self.RegionDataVersion, IntTag(max_world_version[1]))
-        return data
-
-
-export = Anvil0Interface
+from __future__ import annotations
+
+from typing import Tuple, TYPE_CHECKING
+
+from amulet_nbt import IntTag
+
+import amulet
+from .base_anvil_interface import ChunkPathType, ChunkDataType
+from .anvil_na import AnvilNAInterface as ParentInterface
+
+if TYPE_CHECKING:
+    from amulet.api.chunk import Chunk
+
+
+class Anvil0Interface(ParentInterface):
+    """
+    Added the DataVersion tag
+    Note that this has not been tested before 1.12
+    """
+
+    V = None
+    RegionDataVersion: ChunkPathType = (
+        "region",
+        [("DataVersion", IntTag)],
+        IntTag,
+    )
+
+    def __init__(self):
+        super().__init__()
+        self._unregister_decoder(self._decode_v_tag)
+        self._unregister_encoder(self._encode_v_tag)
+
+        self._register_post_decoder(self._post_decode_data_version)
+
+    @staticmethod
+    def minor_is_valid(key: int):
+        return 0 <= key < 1444
+
+    def _post_decode_data_version(
+        self, chunk: Chunk, data: ChunkDataType, floor_cy: int, height_cy: int
+    ):
+        # all versioned data must get removed from data
+        self.get_layer_obj(data, self.RegionDataVersion, pop_last=True)
+
+    def _decode_entities(
+        self, chunk: Chunk, data: ChunkDataType, floor_cy: int, height_cy: int
+    ):
+        ents = self._decode_entity_list(
+            self.get_layer_obj(data, self.Entities, pop_last=True)
+        )
+        if amulet.entity_support:
+            chunk.entities = ents
+        else:
+            chunk._native_entities.extend(ents)
+            chunk._native_version = (
+                "java",
+                self.get_layer_obj(data, self.RegionDataVersion).py_int,
+            )
+
+    def _init_encode(
+        self,
+        chunk: Chunk,
+        max_world_version: Tuple[str, int],
+        floor_cy: int,
+        height_cy: int,
+    ) -> ChunkDataType:
+        data = super()._init_encode(chunk, max_world_version, floor_cy, height_cy)
+        self.set_layer_obj(data, self.RegionDataVersion, IntTag(max_world_version[1]))
+        return data
+
+
+export = Anvil0Interface