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

amulet/operations/delete_chunk.py

@@ -1,32 +1,32 @@
-from amulet.api.selection import SelectionGroup
-from amulet.api.data_types import Dimension
-from amulet.api.chunk import Chunk
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-
-
-def delete_chunk(
-    world: "BaseLevel",
-    dimension: Dimension,
-    source_box: SelectionGroup,
-    load_original: bool = True,
-):
-    chunks = [
-        (cx, cz)
-        for (cx, cz) in source_box.chunk_locations()
-        if world.has_chunk(cx, cz, dimension)
-    ]
-    iter_count = len(chunks)
-    for count, (cx, cz) in enumerate(chunks):
-        world.delete_chunk(cx, cz, dimension)
-
-        if not load_original:
-            # this part is kind of hacky.
-            # Work out a propery API to do this.
-            key = dimension, cx, cz
-            if key not in world.chunks._history_database:
-                world.chunks._register_original_entry(key, Chunk(cx, cz))
-
-        yield (count + 1) / iter_count
+from amulet.api.selection import SelectionGroup
+from amulet.api.data_types import Dimension
+from amulet.api.chunk import Chunk
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+
+
+def delete_chunk(
+    world: "BaseLevel",
+    dimension: Dimension,
+    source_box: SelectionGroup,
+    load_original: bool = True,
+):
+    chunks = [
+        (cx, cz)
+        for (cx, cz) in source_box.chunk_locations()
+        if world.has_chunk(cx, cz, dimension)
+    ]
+    iter_count = len(chunks)
+    for count, (cx, cz) in enumerate(chunks):
+        world.delete_chunk(cx, cz, dimension)
+
+        if not load_original:
+            # this part is kind of hacky.
+            # Work out a propery API to do this.
+            key = dimension, cx, cz
+            if key not in world.chunks._history_database:
+                world.chunks._register_original_entry(key, Chunk(cx, cz))
+
+        yield (count + 1) / iter_count

amulet/operations/fill.py

@@ -1,30 +1,30 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from amulet.api.selection import SelectionGroup
-from amulet.api.block import Block
-from amulet.api.data_types import Dimension, OperationReturnType
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-
-
-def fill(
-    world: "BaseLevel",
-    dimension: Dimension,
-    target_box: SelectionGroup,
-    fill_block: Block,
-) -> OperationReturnType:
-    if not isinstance(fill_block, Block):
-        raise Exception("Fill operation was not given a Block object")
-    internal_id = world.block_palette.get_add_block(fill_block)
-
-    iter_count = len(list(world.get_coord_box(dimension, target_box, True)))
-    count = 0
-
-    for chunk, slices, _ in world.get_chunk_slice_box(dimension, target_box, True):
-        chunk.blocks[slices] = internal_id
-        chunk.changed = True
-        count += 1
-        yield count / iter_count
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from amulet.api.selection import SelectionGroup
+from amulet.api.block import Block
+from amulet.api.data_types import Dimension, OperationReturnType
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+
+
+def fill(
+    world: "BaseLevel",
+    dimension: Dimension,
+    target_box: SelectionGroup,
+    fill_block: Block,
+) -> OperationReturnType:
+    if not isinstance(fill_block, Block):
+        raise Exception("Fill operation was not given a Block object")
+    internal_id = world.block_palette.get_add_block(fill_block)
+
+    iter_count = len(list(world.get_coord_box(dimension, target_box, True)))
+    count = 0
+
+    for chunk, slices, _ in world.get_chunk_slice_box(dimension, target_box, True):
+        chunk.blocks[slices] = internal_id
+        chunk.changed = True
+        count += 1
+        yield count / iter_count

amulet/operations/paste.py

@@ -1,65 +1,65 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from amulet.api.data_types import Dimension, BlockCoordinates, FloatTriplet
-from amulet.api.block import Block, UniversalAirLikeBlocks
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-
-
-def paste(
-    dst: "BaseLevel",
-    dst_dimension: Dimension,
-    src: "BaseLevel",
-    src_dimension: Dimension,
-    location: BlockCoordinates,
-    scale: FloatTriplet,
-    rotation: FloatTriplet,
-    copy_air=True,
-    copy_water=True,
-    copy_lava=True,
-):
-    for _ in paste_iter(
-        dst,
-        dst_dimension,
-        src,
-        src_dimension,
-        location,
-        scale,
-        rotation,
-        copy_air,
-        copy_water,
-        copy_lava,
-    ):
-        pass
-
-
-def paste_iter(
-    dst: "BaseLevel",
-    dst_dimension: Dimension,
-    src: "BaseLevel",
-    src_dimension: Dimension,
-    location: BlockCoordinates,
-    scale: FloatTriplet,
-    rotation: FloatTriplet,
-    copy_air=True,
-    copy_water=True,
-    copy_lava=True,
-):
-    yield from dst.paste_iter(
-        src,
-        src_dimension,
-        src.bounds(src_dimension),
-        dst_dimension,
-        location,
-        scale,
-        rotation,
-        True,
-        True,
-        tuple(UniversalAirLikeBlocks) * bool(not copy_air)
-        + (Block("universal_minecraft", "water"),) * bool(not copy_water)
-        + (Block("universal_minecraft", "lava"),) * bool(not copy_lava),
-        True,
-    )
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from amulet.api.data_types import Dimension, BlockCoordinates, FloatTriplet
+from amulet.api.block import Block, UniversalAirLikeBlocks
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+
+
+def paste(
+    dst: "BaseLevel",
+    dst_dimension: Dimension,
+    src: "BaseLevel",
+    src_dimension: Dimension,
+    location: BlockCoordinates,
+    scale: FloatTriplet,
+    rotation: FloatTriplet,
+    copy_air=True,
+    copy_water=True,
+    copy_lava=True,
+):
+    for _ in paste_iter(
+        dst,
+        dst_dimension,
+        src,
+        src_dimension,
+        location,
+        scale,
+        rotation,
+        copy_air,
+        copy_water,
+        copy_lava,
+    ):
+        pass
+
+
+def paste_iter(
+    dst: "BaseLevel",
+    dst_dimension: Dimension,
+    src: "BaseLevel",
+    src_dimension: Dimension,
+    location: BlockCoordinates,
+    scale: FloatTriplet,
+    rotation: FloatTriplet,
+    copy_air=True,
+    copy_water=True,
+    copy_lava=True,
+):
+    yield from dst.paste_iter(
+        src,
+        src_dimension,
+        src.bounds(src_dimension),
+        dst_dimension,
+        location,
+        scale,
+        rotation,
+        True,
+        True,
+        tuple(UniversalAirLikeBlocks) * bool(not copy_air)
+        + (Block("universal_minecraft", "water"),) * bool(not copy_water)
+        + (Block("universal_minecraft", "lava"),) * bool(not copy_lava),
+        True,
+    )

amulet/operations/replace.py

@@ -1,58 +1,58 @@
-from __future__ import annotations
-
-from typing import List, TYPE_CHECKING
-import logging
-
-from amulet.api.selection import SelectionGroup
-from amulet.api.block import Block
-from amulet.api.data_types import Dimension
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-
-log = logging.getLogger(__name__)
-
-
-def replace(
-    world: "BaseLevel", dimension: Dimension, selection: SelectionGroup, options: dict
-):
-    original_blocks = options.get("original_blocks", None)
-    if not isinstance(original_blocks, list) and all(
-        isinstance(block, Block) for block in original_blocks
-    ):
-        log.error("Replace operation was not given a list of source Block objects")
-        return
-
-    replacement_blocks = options.get("replacement_blocks", None)
-    if not isinstance(replacement_blocks, list) and all(
-        isinstance(block, Block) for block in replacement_blocks
-    ):
-        log.error("Replace operation was not given a list of destination Block objects")
-        return
-    original_blocks: List[Block]
-    replacement_blocks: List[Block]
-
-    if len(original_blocks) != len(replacement_blocks):
-        if len(replacement_blocks) == 1:
-            replacement_blocks = replacement_blocks * len(original_blocks)
-        else:
-            log.error(
-                "Replace operation must be given the same number of destination blocks as source blocks"
-            )
-
-    original_internal_ids = list(
-        map(world.block_palette.get_add_block, original_blocks)
-    )
-    replacement_internal_ids = list(
-        map(world.block_palette.get_add_block, replacement_blocks)
-    )
-
-    for chunk, slices, _ in world.get_chunk_slice_box(dimension, selection):
-        old_blocks = chunk.blocks[slices]
-        new_blocks = old_blocks.copy()
-        for original_id, replacement_id in zip(
-            original_internal_ids, replacement_internal_ids
-        ):
-            new_blocks[old_blocks == original_id] = replacement_id
-        chunk.blocks[slices] = new_blocks
-        chunk.changed = True
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
+import logging
+
+from amulet.api.selection import SelectionGroup
+from amulet.api.block import Block
+from amulet.api.data_types import Dimension
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+
+log = logging.getLogger(__name__)
+
+
+def replace(
+    world: "BaseLevel", dimension: Dimension, selection: SelectionGroup, options: dict
+):
+    original_blocks = options.get("original_blocks", None)
+    if not isinstance(original_blocks, list) and all(
+        isinstance(block, Block) for block in original_blocks
+    ):
+        log.error("Replace operation was not given a list of source Block objects")
+        return
+
+    replacement_blocks = options.get("replacement_blocks", None)
+    if not isinstance(replacement_blocks, list) and all(
+        isinstance(block, Block) for block in replacement_blocks
+    ):
+        log.error("Replace operation was not given a list of destination Block objects")
+        return
+    original_blocks: List[Block]
+    replacement_blocks: List[Block]
+
+    if len(original_blocks) != len(replacement_blocks):
+        if len(replacement_blocks) == 1:
+            replacement_blocks = replacement_blocks * len(original_blocks)
+        else:
+            log.error(
+                "Replace operation must be given the same number of destination blocks as source blocks"
+            )
+
+    original_internal_ids = list(
+        map(world.block_palette.get_add_block, original_blocks)
+    )
+    replacement_internal_ids = list(
+        map(world.block_palette.get_add_block, replacement_blocks)
+    )
+
+    for chunk, slices, _ in world.get_chunk_slice_box(dimension, selection):
+        old_blocks = chunk.blocks[slices]
+        new_blocks = old_blocks.copy()
+        for original_id, replacement_id in zip(
+            original_internal_ids, replacement_internal_ids
+        ):
+            new_blocks[old_blocks == original_id] = replacement_id
+        chunk.blocks[slices] = new_blocks
+        chunk.changed = True

amulet/utils/__init__.py

@@ -1,14 +1,14 @@
-from .world_utils import (
-    SECTOR_BYTES,
-    SECTOR_INTS,
-    CHUNK_HEADER_SIZE,
-    VERSION_GZIP,
-    VERSION_DEFLATE,
-    block_coords_to_chunk_coords,
-    chunk_coords_to_region_coords,
-    region_coords_to_chunk_coords,
-    blocks_slice_to_chunk_slice,
-    gunzip,
-    from_nibble_array,
-)
-from .format_utils import *
+from .world_utils import (
+    SECTOR_BYTES,
+    SECTOR_INTS,
+    CHUNK_HEADER_SIZE,
+    VERSION_GZIP,
+    VERSION_DEFLATE,
+    block_coords_to_chunk_coords,
+    chunk_coords_to_region_coords,
+    region_coords_to_chunk_coords,
+    blocks_slice_to_chunk_slice,
+    gunzip,
+    from_nibble_array,
+)
+from .format_utils import *

amulet/utils/format_utils.py

@@ -1,41 +1,41 @@
-from __future__ import annotations
-
-import os
-import warnings
-
-from amulet_nbt import load as load_nbt, NamedTag
-
-
-def check_all_exist(in_dir: str, *args: str) -> bool:
-    """
-    Check that all files exist in a parent directory
-
-    :param in_dir: The parent directory
-    :param args: file or folder names to look for
-    :return: Boolean value indicating whether all were found
-    """
-
-    return all(os.path.exists(os.path.join(in_dir, child)) for child in args)
-
-
-def check_one_exists(in_dir: str, *args: str) -> bool:
-    """
-    Check that at least one file exists in a parent directory
-
-    :param in_dir: The parent directory
-    :param args: file or folder names to look for
-    :return: Boolean value indicating whether at least one was found
-    """
-
-    return any(os.path.exists(os.path.join(in_dir, child)) for child in args)
-
-
-def load_leveldat(in_dir: str) -> NamedTag:
-    """
-    Load the root tag of the level.dat file in the directory
-
-    :param in_dir: The world directory containing the level.dat file
-    :return: The NBT root tag
-    """
-    warnings.warn("load_leveldat is depreciated.", DeprecationWarning)
-    return load_nbt(os.path.join(in_dir, "level.dat"))
+from __future__ import annotations
+
+import os
+import warnings
+
+from amulet_nbt import load as load_nbt, NamedTag
+
+
+def check_all_exist(in_dir: str, *args: str) -> bool:
+    """
+    Check that all files exist in a parent directory
+
+    :param in_dir: The parent directory
+    :param args: file or folder names to look for
+    :return: Boolean value indicating whether all were found
+    """
+
+    return all(os.path.exists(os.path.join(in_dir, child)) for child in args)
+
+
+def check_one_exists(in_dir: str, *args: str) -> bool:
+    """
+    Check that at least one file exists in a parent directory
+
+    :param in_dir: The parent directory
+    :param args: file or folder names to look for
+    :return: Boolean value indicating whether at least one was found
+    """
+
+    return any(os.path.exists(os.path.join(in_dir, child)) for child in args)
+
+
+def load_leveldat(in_dir: str) -> NamedTag:
+    """
+    Load the root tag of the level.dat file in the directory
+
+    :param in_dir: The world directory containing the level.dat file
+    :return: The NBT root tag
+    """
+    warnings.warn("load_leveldat is depreciated.", DeprecationWarning)
+    return load_nbt(os.path.join(in_dir, "level.dat"))

amulet/utils/generator.py

@@ -1,15 +1,15 @@
-from typing import Generator
-
-
-def generator_unpacker(gen: Generator):
-    """
-    Unpack a generator and return the value returned by the generator.
-
-    :param gen: The generator to unpack.
-    :return: The value that was returned by the generator.
-    """
-    try:
-        while True:
-            next(gen)
-    except StopIteration as e:
-        return e.value
+from typing import Generator
+
+
+def generator_unpacker(gen: Generator):
+    """
+    Unpack a generator and return the value returned by the generator.
+
+    :param gen: The generator to unpack.
+    :return: The value that was returned by the generator.
+    """
+    try:
+        while True:
+            next(gen)
+    except StopIteration as e:
+        return e.value