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

amulet/level/translators/chunk/bedrock/bedrock_numerical_translator.py

@@ -1,39 +1,39 @@
-from __future__ import annotations
-
-import numpy
-from typing import TYPE_CHECKING
-
-from amulet.level.translators.chunk.bedrock import BaseBedrockTranslator
-from amulet.api.data_types import BlockNDArray, AnyNDArray
-
-if TYPE_CHECKING:
-    from amulet.api.block import Block
-    from PyMCTranslate import Version
-
-
-class BedrockNumericalTranslator(BaseBedrockTranslator):
-    @staticmethod
-    def is_valid(key):
-        return key[0] == "bedrock" and key[1] < (1, 2, 13)
-
-    def _pack_block_palette(
-        self, version: "Version", palette: BlockNDArray
-    ) -> AnyNDArray:
-        """
-        Packs a numpy array of Block objects into an object array containing version number, block ids and block data values.
-        :param version:
-        :param palette:
-        :return: numpy.ndarray[Tuple[Tuple[Optional[VersionNumber], Tuple[int, int]]]]
-        """
-        palette_ = numpy.empty(len(palette), dtype=object)
-        for palette_index, entry in enumerate(palette):
-            entry: "Block"
-            block_tuple = version.block.block_to_ints(entry)
-            if block_tuple is None:
-                block_tuple = (0, 0)  # TODO: find some way for the user to specify this
-            palette_[palette_index] = ((None, block_tuple),)
-
-        return palette_
-
-
-export = BedrockNumericalTranslator
+from __future__ import annotations
+
+import numpy
+from typing import TYPE_CHECKING
+
+from amulet.level.translators.chunk.bedrock import BaseBedrockTranslator
+from amulet.api.data_types import BlockNDArray, AnyNDArray
+
+if TYPE_CHECKING:
+    from amulet.api.block import Block
+    from PyMCTranslate import Version
+
+
+class BedrockNumericalTranslator(BaseBedrockTranslator):
+    @staticmethod
+    def is_valid(key):
+        return key[0] == "bedrock" and key[1] < (1, 2, 13)
+
+    def _pack_block_palette(
+        self, version: "Version", palette: BlockNDArray
+    ) -> AnyNDArray:
+        """
+        Packs a numpy array of Block objects into an object array containing version number, block ids and block data values.
+        :param version:
+        :param palette:
+        :return: numpy.ndarray[Tuple[Tuple[Optional[VersionNumber], Tuple[int, int]]]]
+        """
+        palette_ = numpy.empty(len(palette), dtype=object)
+        for palette_index, entry in enumerate(palette):
+            entry: "Block"
+            block_tuple = version.block.block_to_ints(entry)
+            if block_tuple is None:
+                block_tuple = (0, 0)  # TODO: find some way for the user to specify this
+            palette_[palette_index] = ((None, block_tuple),)
+
+        return palette_
+
+
+export = BedrockNumericalTranslator

amulet/level/translators/chunk/bedrock/bedrock_psudo_numerical_translator.py

@@ -1,37 +1,37 @@
-from __future__ import annotations
-
-import numpy
-from typing import TYPE_CHECKING
-
-from amulet.level.translators.chunk.bedrock import BaseBedrockTranslator
-from amulet.api.data_types import BlockNDArray, AnyNDArray
-
-if TYPE_CHECKING:
-    from amulet.api.block import Block
-    from PyMCTranslate import Version
-
-
-class BedrockPsudoNumericalTranslator(BaseBedrockTranslator):
-    @staticmethod
-    def is_valid(key):
-        return key[0] == "bedrock" and (1, 2, 13) <= key[1] < (1, 13, 0)
-
-    def _pack_block_palette(
-        self, version: "Version", palette: BlockNDArray
-    ) -> AnyNDArray:
-        """
-        Packs a numpy array of Block objects into an object array containing one pair of version number and Block objects.
-        :param version:
-        :param palette:
-        :return: numpy.ndarray[Tuple[Tuple[Optional[VersionNumber], Block]]]
-        """
-        palette_ = numpy.empty(len(palette), dtype=object)
-        for palette_index, block in enumerate(palette):
-            block: "Block"
-            # TODO: perhaps check that property 'block_data' exists and is IntTag user interaction if not
-            palette_[palette_index] = tuple((None, b) for b in block.block_tuple)
-
-        return palette_
-
-
-export = BedrockPsudoNumericalTranslator
+from __future__ import annotations
+
+import numpy
+from typing import TYPE_CHECKING
+
+from amulet.level.translators.chunk.bedrock import BaseBedrockTranslator
+from amulet.api.data_types import BlockNDArray, AnyNDArray
+
+if TYPE_CHECKING:
+    from amulet.api.block import Block
+    from PyMCTranslate import Version
+
+
+class BedrockPsudoNumericalTranslator(BaseBedrockTranslator):
+    @staticmethod
+    def is_valid(key):
+        return key[0] == "bedrock" and (1, 2, 13) <= key[1] < (1, 13, 0)
+
+    def _pack_block_palette(
+        self, version: "Version", palette: BlockNDArray
+    ) -> AnyNDArray:
+        """
+        Packs a numpy array of Block objects into an object array containing one pair of version number and Block objects.
+        :param version:
+        :param palette:
+        :return: numpy.ndarray[Tuple[Tuple[Optional[VersionNumber], Block]]]
+        """
+        palette_ = numpy.empty(len(palette), dtype=object)
+        for palette_index, block in enumerate(palette):
+            block: "Block"
+            # TODO: perhaps check that property 'block_data' exists and is IntTag user interaction if not
+            palette_[palette_index] = tuple((None, b) for b in block.block_tuple)
+
+        return palette_
+
+
+export = BedrockPsudoNumericalTranslator

amulet/level/translators/chunk/java/java_1_18_translator.py

@@ -1,40 +1,40 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from amulet.api.chunk import Chunk
-from amulet.api.data_types import (
-    VersionIdentifierType,
-)
-
-if TYPE_CHECKING:
-    from PyMCTranslate import Version, TranslationManager
-
-from .java_blockstate_translator import JavaBlockstateTranslator
-
-
-class Java118Translator(JavaBlockstateTranslator):
-    # TODO: move this logic into the interface
-
-    @staticmethod
-    def is_valid(key):
-        return key[0] == "java" and 2836 <= key[1]
-
-    @staticmethod
-    def _unpack_biomes(
-        translation_manager: "TranslationManager",
-        version_identifier: VersionIdentifierType,
-        chunk: Chunk,
-    ):
-        pass
-
-    @staticmethod
-    def _pack_biomes(
-        translation_manager: "TranslationManager",
-        version_identifier: VersionIdentifierType,
-        chunk: Chunk,
-    ):
-        pass
-
-
-export = Java118Translator
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from amulet.api.chunk import Chunk
+from amulet.api.data_types import (
+    VersionIdentifierType,
+)
+
+if TYPE_CHECKING:
+    from PyMCTranslate import Version, TranslationManager
+
+from .java_blockstate_translator import JavaBlockstateTranslator
+
+
+class Java118Translator(JavaBlockstateTranslator):
+    # TODO: move this logic into the interface
+
+    @staticmethod
+    def is_valid(key):
+        return key[0] == "java" and 2836 <= key[1]
+
+    @staticmethod
+    def _unpack_biomes(
+        translation_manager: "TranslationManager",
+        version_identifier: VersionIdentifierType,
+        chunk: Chunk,
+    ):
+        pass
+
+    @staticmethod
+    def _pack_biomes(
+        translation_manager: "TranslationManager",
+        version_identifier: VersionIdentifierType,
+        chunk: Chunk,
+    ):
+        pass
+
+
+export = Java118Translator

amulet/level/translators/chunk/java/java_blockstate_translator.py

@@ -1,94 +1,94 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from amulet_nbt import StringTag
-
-from amulet.api.chunk import Chunk
-from amulet.api.wrapper import Translator
-from amulet.api.block import Block
-from amulet.api.registry import BlockManager
-from amulet.api.data_types import (
-    VersionIdentifierType,
-    AnyNDArray,
-    BlockNDArray,
-)
-
-if TYPE_CHECKING:
-    from PyMCTranslate import Version, TranslationManager
-
-water = Block.from_string_blockstate("minecraft:water[level=0]")
-
-
-class JavaBlockstateTranslator(Translator):
-    def _translator_key(self, version_number: int) -> VersionIdentifierType:
-        return "java", version_number
-
-    @staticmethod
-    def is_valid(key):
-        return key[0] == "java" and 1444 <= key[1] < 2836
-
-    @staticmethod
-    def _unpack_blocks(
-        translation_manager: "TranslationManager",
-        version_identifier: VersionIdentifierType,
-        chunk: Chunk,
-        block_palette: AnyNDArray,
-    ):
-        """
-        Unpack the version-specific block_palette into the stringified version where needed.
-
-        :return: The block_palette converted to block objects.
-        """
-        version = translation_manager.get_version(*version_identifier)
-        for index, block in enumerate(block_palette):
-            block: Block
-            if version.block.is_waterloggable(block.namespaced_name):
-                properties = block.properties
-                if "waterlogged" in properties:
-                    waterlogged = properties["waterlogged"]
-                    del properties["waterlogged"]
-                    block = Block(
-                        namespace=block.namespace,
-                        base_name=block.base_name,
-                        properties=properties,
-                    )
-                else:
-                    waterlogged = StringTag("false")
-
-                if waterlogged == StringTag("true"):
-                    block_palette[index] = block + water
-                else:
-                    block_palette[index] = block
-            elif version.block.is_waterloggable(block.namespaced_name, True):
-                block_palette[index] = block + water
-
-        chunk._block_palette = BlockManager(block_palette)
-
-    def _pack_block_palette(
-        self, version: "Version", palette: BlockNDArray
-    ) -> AnyNDArray:
-        """
-        Translate the list of block objects into a version-specific block_palette.
-        :return: The block_palette converted into version-specific blocks (ie id, data tuples for 1.12)
-        """
-        for index, block in enumerate(palette):
-            block: Block
-            if version.block.is_waterloggable(block.namespaced_name):
-                properties = block.properties
-                extra_blocks = block.extra_blocks
-                if (
-                    extra_blocks
-                    and extra_blocks[0].namespaced_name == water.namespaced_name
-                ):
-                    properties["waterlogged"] = StringTag("true")
-                else:
-                    properties["waterlogged"] = StringTag("false")
-                palette[index] = Block(
-                    namespace=block.namespace,
-                    base_name=block.base_name,
-                    properties=properties,
-                )
-        return palette
-
-
-export = JavaBlockstateTranslator
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from amulet_nbt import StringTag
+
+from amulet.api.chunk import Chunk
+from amulet.api.wrapper import Translator
+from amulet.api.block import Block
+from amulet.api.registry import BlockManager
+from amulet.api.data_types import (
+    VersionIdentifierType,
+    AnyNDArray,
+    BlockNDArray,
+)
+
+if TYPE_CHECKING:
+    from PyMCTranslate import Version, TranslationManager
+
+water = Block.from_string_blockstate("minecraft:water[level=0]")
+
+
+class JavaBlockstateTranslator(Translator):
+    def _translator_key(self, version_number: int) -> VersionIdentifierType:
+        return "java", version_number
+
+    @staticmethod
+    def is_valid(key):
+        return key[0] == "java" and 1444 <= key[1] < 2836
+
+    @staticmethod
+    def _unpack_blocks(
+        translation_manager: "TranslationManager",
+        version_identifier: VersionIdentifierType,
+        chunk: Chunk,
+        block_palette: AnyNDArray,
+    ):
+        """
+        Unpack the version-specific block_palette into the stringified version where needed.
+
+        :return: The block_palette converted to block objects.
+        """
+        version = translation_manager.get_version(*version_identifier)
+        for index, block in enumerate(block_palette):
+            block: Block
+            if version.block.is_waterloggable(block.namespaced_name):
+                properties = block.properties
+                if "waterlogged" in properties:
+                    waterlogged = properties["waterlogged"]
+                    del properties["waterlogged"]
+                    block = Block(
+                        namespace=block.namespace,
+                        base_name=block.base_name,
+                        properties=properties,
+                    )
+                else:
+                    waterlogged = StringTag("false")
+
+                if waterlogged == StringTag("true"):
+                    block_palette[index] = block + water
+                else:
+                    block_palette[index] = block
+            elif version.block.is_waterloggable(block.namespaced_name, True):
+                block_palette[index] = block + water
+
+        chunk._block_palette = BlockManager(block_palette)
+
+    def _pack_block_palette(
+        self, version: "Version", palette: BlockNDArray
+    ) -> AnyNDArray:
+        """
+        Translate the list of block objects into a version-specific block_palette.
+        :return: The block_palette converted into version-specific blocks (ie id, data tuples for 1.12)
+        """
+        for index, block in enumerate(palette):
+            block: Block
+            if version.block.is_waterloggable(block.namespaced_name):
+                properties = block.properties
+                extra_blocks = block.extra_blocks
+                if (
+                    extra_blocks
+                    and extra_blocks[0].namespaced_name == water.namespaced_name
+                ):
+                    properties["waterlogged"] = StringTag("true")
+                else:
+                    properties["waterlogged"] = StringTag("false")
+                palette[index] = Block(
+                    namespace=block.namespace,
+                    base_name=block.base_name,
+                    properties=properties,
+                )
+        return palette
+
+
+export = JavaBlockstateTranslator

amulet/level/translators/chunk/java/java_numerical_translator.py

@@ -1,62 +1,62 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-import numpy
-
-from amulet.api.chunk import Chunk
-from amulet.api.wrapper import Translator
-from amulet.api.data_types import VersionIdentifierType, AnyNDArray, BlockNDArray
-from amulet.api.registry import BlockManager
-
-if TYPE_CHECKING:
-    from PyMCTranslate import Version, TranslationManager
-
-
-class JavaNumericalTranslator(Translator):
-    def _translator_key(self, version_number: int) -> VersionIdentifierType:
-        return "java", version_number
-
-    @staticmethod
-    def _unpack_blocks(
-        translation_manager: "TranslationManager",
-        version_identifier: VersionIdentifierType,
-        chunk: Chunk,
-        block_palette: AnyNDArray,
-    ):
-        """
-        Unpacks an int array of block ids and block data values [[1, 0], [2, 0]] into a numpy array of Block objects.
-        :param translation_manager:
-        :param version_identifier:
-        :param chunk:
-        :param block_palette:
-        :return:
-        """
-        version = translation_manager.get_version(*version_identifier)
-        chunk._block_palette = BlockManager(
-            [version.block.ints_to_block(*entry) for entry in block_palette]
-        )
-
-    def _pack_block_palette(
-        self, version: "Version", palette: BlockNDArray
-    ) -> AnyNDArray:
-        """
-        Packs a numpy array of Block objects into an int array of block ids and block data values [[1, 0], [2, 0]].
-        :param version:
-        :param palette:
-        :return:
-        """
-        palette = [version.block.block_to_ints(entry) for entry in palette]
-        for index, value in enumerate(palette):
-            if value is None:
-                palette[index] = (
-                    0,
-                    0,
-                )  # TODO: find some way for the user to specify this
-        return numpy.array(palette)
-
-    @staticmethod
-    def is_valid(key):
-        return key[0] == "java" and key[1] <= 1343
-
-
-export = JavaNumericalTranslator
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+import numpy
+
+from amulet.api.chunk import Chunk
+from amulet.api.wrapper import Translator
+from amulet.api.data_types import VersionIdentifierType, AnyNDArray, BlockNDArray
+from amulet.api.registry import BlockManager
+
+if TYPE_CHECKING:
+    from PyMCTranslate import Version, TranslationManager
+
+
+class JavaNumericalTranslator(Translator):
+    def _translator_key(self, version_number: int) -> VersionIdentifierType:
+        return "java", version_number
+
+    @staticmethod
+    def _unpack_blocks(
+        translation_manager: "TranslationManager",
+        version_identifier: VersionIdentifierType,
+        chunk: Chunk,
+        block_palette: AnyNDArray,
+    ):
+        """
+        Unpacks an int array of block ids and block data values [[1, 0], [2, 0]] into a numpy array of Block objects.
+        :param translation_manager:
+        :param version_identifier:
+        :param chunk:
+        :param block_palette:
+        :return:
+        """
+        version = translation_manager.get_version(*version_identifier)
+        chunk._block_palette = BlockManager(
+            [version.block.ints_to_block(*entry) for entry in block_palette]
+        )
+
+    def _pack_block_palette(
+        self, version: "Version", palette: BlockNDArray
+    ) -> AnyNDArray:
+        """
+        Packs a numpy array of Block objects into an int array of block ids and block data values [[1, 0], [2, 0]].
+        :param version:
+        :param palette:
+        :return:
+        """
+        palette = [version.block.block_to_ints(entry) for entry in palette]
+        for index, value in enumerate(palette):
+            if value is None:
+                palette[index] = (
+                    0,
+                    0,
+                )  # TODO: find some way for the user to specify this
+        return numpy.array(palette)
+
+    @staticmethod
+    def is_valid(key):
+        return key[0] == "java" and key[1] <= 1343
+
+
+export = JavaNumericalTranslator

amulet/libs/leveldb/__init__.py

@@ -1,7 +1,7 @@
-import warnings
-
-warnings.warn(
-    "`amulet.libs.leveldb` is depreciated and will be removed in the future. It is replaced by the `leveldb` package.",
-    DeprecationWarning,
-)
-from leveldb import LevelDB, LevelDBException, LevelDBEncrypted
+import warnings
+
+warnings.warn(
+    "`amulet.libs.leveldb` is depreciated and will be removed in the future. It is replaced by the `leveldb` package.",
+    DeprecationWarning,
+)
+from leveldb import LevelDB, LevelDBException, LevelDBEncrypted

amulet/operations/__init__.py

@@ -1,5 +1,5 @@
-from .clone import clone
-from .delete_chunk import delete_chunk
-from .fill import fill
-from .paste import paste
-from .replace import replace
+from .clone import clone
+from .delete_chunk import delete_chunk
+from .fill import fill
+from .paste import paste
+from .replace import replace

amulet/operations/clone.py

@@ -1,18 +1,18 @@
-from amulet.api.selection import SelectionGroup
-from amulet.api.data_types import Dimension
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-
-
-def clone(
-    world: "BaseLevel", dimension: Dimension, selection: SelectionGroup, target: dict
-):
-    offset_x, offset_y, offset_z = (selection.max_array - selection.min_array) // 2
-    dst_location = (
-        target.get("x", 0) + offset_x,
-        target.get("y", 0) + offset_y,
-        target.get("z", 0) + offset_y,
-    )
-    world.paste(world, dimension, selection, dimension, dst_location)
+from amulet.api.selection import SelectionGroup
+from amulet.api.data_types import Dimension
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+
+
+def clone(
+    world: "BaseLevel", dimension: Dimension, selection: SelectionGroup, target: dict
+):
+    offset_x, offset_y, offset_z = (selection.max_array - selection.min_array) // 2
+    dst_location = (
+        target.get("x", 0) + offset_x,
+        target.get("y", 0) + offset_y,
+        target.get("z", 0) + offset_y,
+    )
+    world.paste(world, dimension, selection, dimension, dst_location)