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

amulet/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-08-16T10:37:55+0100",
+ "date": "2023-09-29T11:29:40+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "dafef97fe4fd1f2f713ef1e3503d6b13b20c1c1f",
- "version": "1.9.18"
+ "full-revisionid": "b673f749bf1c348e31bf0594e71ffa30f6ea8519",
+ "version": "1.9.20"
 }
 '''  # END VERSION_JSON
 

amulet/api/level/base_level/base_level.py

@@ -770,11 +770,19 @@ class BaseLevel:
         chunk = self.get_chunk(cx, cz, dimension)
         offset_x, offset_z = x - 16 * cx, z - 16 * cz
 
-        output, extra_output, _ = self.translation_manager.get_version(
-            *version
-        ).block.from_universal(
-            chunk.get_block(offset_x, y, offset_z), chunk.block_entities.get((x, y, z))
+        translator = self.translation_manager.get_version(*version).block
+
+        src_blocks = chunk.get_block(offset_x, y, offset_z).block_tuple
+        src_block_entity = chunk.block_entities.get((x, y, z))
+
+        output, extra_output, _ = translator.from_universal(
+            src_blocks[0], src_block_entity
         )
+        if isinstance(output, Block):
+            for src_block in src_blocks[1:]:
+                converted_sub_block = translator.from_universal(src_block)[0]
+                if isinstance(converted_sub_block, Block):
+                    output += converted_sub_block
         return output, extra_output
 
     def set_version_block(
@@ -812,13 +820,14 @@ class BaseLevel:
             chunk = self.create_chunk(cx, cz, dimension)
         offset_x, offset_z = x - 16 * cx, z - 16 * cz
 
-        (
-            universal_block,
-            universal_block_entity,
-            _,
-        ) = self.translation_manager.get_version(*version).block.to_universal(
-            block, block_entity
+        translator = self.translation_manager.get_version(*version).block
+        src_blocks = block.block_tuple
+
+        universal_block, universal_block_entity, _ = translator.to_universal(
+            src_blocks[0], block_entity
         )
+        for src_block in src_blocks[1:]:
+            universal_block += translator.to_universal(src_block)[0]
         chunk.set_block(offset_x, y, offset_z, universal_block),
         if isinstance(universal_block_entity, BlockEntity):
             chunk.block_entities[(x, y, z)] = universal_block_entity

amulet/level/formats/anvil_world/_sector_manager.py

@@ -141,9 +141,9 @@ class SectorManager:
 
     @property
     def sectors(self) -> List[Sector]:
-        """A list of reserved sectors"""
+        """A list of reserved sectors. Ordered by their start location."""
         with self._lock:
-            return list(self._reserved)
+            return list(sorted(self._reserved, key=lambda i: i.start))
 
     def reserve_space(self, length: int) -> Sector:
         """
@@ -170,6 +170,7 @@ class SectorManager:
                     self._free_start[start_index] = free_sector
                 else:
                     del self._free_start[start_index]
+                self._reserved.add(sector)
                 return sector
             elif self._resizable:
                 sector = Sector(self._stop, self._stop + length)
@@ -261,6 +262,8 @@ class SectorManager:
         :param sector: The sector to free
         """
         with self._lock:
+            if sector not in self._reserved:
+                raise ValueError("Sector was not reserved")
             # remove the sector from the reserved storage
             self._reserved.remove(sector)
 
@@ -286,99 +289,3 @@ class SectorManager:
 
             self._free_start.insert(index, sector)
             self._add_size_sector(sector)
-
-
-def validate(m):
-    assert set(m._free_start) == set(m._free_size)
-    free = sorted(list(m._free_start) + list(m._reserved), key=lambda k: k.start)
-    if free:
-        for i in range(len(free) - 1):
-            assert free[i].stop == free[i + 1].start
-        assert free[-1].stop == m._stop
-
-
-def test1():
-    m = SectorManager(2, 3)
-    validate(m)
-    m.reserve(Sector(2, 3))
-    validate(m)
-    m.reserve(Sector(3, 4))
-    validate(m)
-    print(m.sectors)
-
-
-def test2():
-    m = SectorManager(2, 102)
-
-    m.reserve(Sector(5, 6))
-    validate(m)
-    m.reserve(Sector(6, 7))
-    validate(m)
-    # m.reserve(Sector(7, 8))
-    m.reserve(Sector(8, 9))
-    validate(m)
-
-    try:
-        m.reserve(Sector(6, 8))
-    except NoValidSector:
-        pass
-    else:
-        raise Exception
-
-    validate(m)
-
-    try:
-        m.reserve(Sector(7, 9))
-    except NoValidSector:
-        pass
-    else:
-        raise Exception
-
-    validate(m)
-    m.free(Sector(5, 6))
-    validate(m)
-    m.free(Sector(6, 7))
-    validate(m)
-    m.free(Sector(8, 9))
-    validate(m)
-
-    m.reserve(Sector(6, 8))
-    validate(m)
-    m.free(Sector(6, 8))
-    validate(m)
-
-    m.reserve(Sector(7, 9))
-    validate(m)
-    m.free(Sector(7, 9))
-
-    validate(m)
-
-    assert len(m._free_start) == 1
-
-
-# def test3():
-# reserve a number of single length units
-# for _ in range(20):
-#     i = free_indexes.pop(random.randrange(len(free_indexes)))
-#     m.reserve(Sector(i, i+1))
-#     validate(m)
-#     reserved_indexes.append(i)
-#
-# for _ in range(20):
-#     index = random.randrange(len(free_indexes))
-#     di = 1
-#     i = free_indexes.pop(index)
-#
-# for _ in range(10_000):
-#     m.reserve(Sector(i, i+1))
-#     validate(m)
-# print(m.sectors)
-
-
-def test():
-    test1()
-    test2()
-
-
-if __name__ == "__main__":
-    test()

amulet/level/formats/anvil_world/format.py

@@ -231,93 +231,108 @@ class AnvilFormat(WorldFormatWrapper[VersionNumberInt]):
                 layers=("region",) + ("entities",) * (self.version >= 2681),
             )
             self._dimension_name_map[dimension_name] = relative_dimension_path
-            bounds = DefaultSelection
-            if self.version >= 2709:  # This number might be smaller
-                dimension_settings = (
-                    self.root_tag.compound.get_compound("Data", CompoundTag())
-                    .get_compound("WorldGenSettings", CompoundTag())
-                    .get_compound("dimensions", CompoundTag())
-                    .get_compound(dimension_name, CompoundTag())
-                )
-                dimension_tag = dimension_settings.get("type")
-                if isinstance(dimension_tag, StringTag):
-                    # the settings are in the data pack
-                    dimension_name = dimension_tag.py_str
-                    if ":" in dimension_name:
-                        namespace, base_name = dimension_name.split(":", 1)
-                        if (
-                            self.version >= 2834
-                            and namespace == "minecraft"
-                            and base_name == "overworld"
-                        ):
-                            bounds = SelectionGroup(
+            self._bounds[dimension_name] = self._get_dimenion_bounds(dimension_name)
+
+    def _get_dimenion_bounds(self, dimension_type_str: Dimension) -> SelectionGroup:
+        if self.version >= 2709:  # This number might be smaller
+            # If in a version that supports custom height data packs
+            dimension_settings = (
+                self.root_tag.compound.get_compound("Data", CompoundTag())
+                .get_compound("WorldGenSettings", CompoundTag())
+                .get_compound("dimensions", CompoundTag())
+                .get_compound(dimension_type_str, CompoundTag())
+            )
+
+            # "type" can be a reference (string) or inline (compound) dimension-type data.
+            dimension_type = dimension_settings.get("type")
+
+            if isinstance(dimension_type, StringTag):
+                # Reference type. Load the dimension data
+                dimension_type_str = dimension_type.py_str
+                if ":" in dimension_type_str:
+                    namespace, base_name = dimension_type_str.split(":", 1)
+                else:
+                    namespace = "minecraft"
+                    base_name = dimension_type_str
+                name_tuple = namespace, base_name
+
+                # First try and load the reference from the data pack and then from defaults
+                dimension_path = f"data/{namespace}/dimension_type/{base_name}.json"
+                if self.data_pack.has_file(dimension_path):
+                    with self.data_pack.open(dimension_path) as d:
+                        try:
+                            dimension_settings_json = json.load(d)
+                        except json.JSONDecodeError:
+                            pass
+                        else:
+                            if "min_y" in dimension_settings_json and isinstance(
+                                dimension_settings_json["min_y"], int
+                            ):
+                                min_y = dimension_settings_json["min_y"]
+                                if min_y % 16:
+                                    min_y = 16 * (min_y // 16)
+                            else:
+                                min_y = 0
+                            if "height" in dimension_settings_json and isinstance(
+                                dimension_settings_json["height"], int
+                            ):
+                                height = dimension_settings_json["height"]
+                                if height % 16:
+                                    height = -16 * (-height // 16)
+                            else:
+                                height = 256
+
+                            return SelectionGroup(
                                 SelectionBox(
-                                    (-30_000_000, -64, -30_000_000),
-                                    (30_000_000, 320, 30_000_000),
+                                    (-30_000_000, min_y, -30_000_000),
+                                    (30_000_000, min_y + height, 30_000_000),
                                 )
                             )
-                        dimension_path = (
-                            f"data/{namespace}/dimension_type/{base_name}.json"
-                        )
-                        if self.data_pack.has_file(dimension_path):
-                            with self.data_pack.open(dimension_path) as d:
-                                try:
-                                    dimension_settings_json = json.load(d)
-                                except json.JSONDecodeError:
-                                    pass
-                                else:
-                                    if (
-                                        "min_y" in dimension_settings_json
-                                        and isinstance(
-                                            dimension_settings_json["min_y"], int
-                                        )
-                                    ):
-                                        min_y = dimension_settings_json["min_y"]
-                                        if min_y % 16:
-                                            min_y = 16 * (min_y // 16)
-                                    else:
-                                        min_y = 0
-                                    if (
-                                        "height" in dimension_settings_json
-                                        and isinstance(
-                                            dimension_settings_json["height"], int
-                                        )
-                                    ):
-                                        height = dimension_settings_json["height"]
-                                        if height % 16:
-                                            height = -16 * (-height // 16)
-                                    else:
-                                        height = 256
-
-                                    bounds = SelectionGroup(
-                                        SelectionBox(
-                                            (-30_000_000, min_y, -30_000_000),
-                                            (30_000_000, min_y + height, 30_000_000),
-                                        )
-                                    )
-
-                elif isinstance(dimension_tag, CompoundTag):
-                    # the settings are here
-                    dimension_compound_tag = dimension_tag
-                    min_y = (
-                        dimension_compound_tag.get_int("min_y", IntTag()).py_int // 16
-                    ) * 16
-                    height = (
-                        -dimension_compound_tag.get_int("height", IntTag(256)).py_int
-                        // 16
-                    ) * -16
-                    bounds = SelectionGroup(
-                        SelectionBox(
-                            (-30_000_000, min_y, -30_000_000),
-                            (30_000_000, min_y + height, 30_000_000),
+
+                elif name_tuple in {
+                    ("minecraft", "overworld"),
+                    ("minecraft", "overworld_caves"),
+                }:
+                    if self.version >= 2825:
+                        # If newer than the height change version
+                        return SelectionGroup(
+                            SelectionBox(
+                                (-30_000_000, -64, -30_000_000),
+                                (30_000_000, 320, 30_000_000),
+                            )
                         )
-                    )
+                    else:
+                        return DefaultSelection
+                elif name_tuple in {
+                    ("minecraft", "the_nether"),
+                    ("minecraft", "the_end"),
+                }:
+                    return DefaultSelection
                 else:
-                    log.error(
-                        f"Expected dimension_tag to be a StringTag or CompoundTag. Got {repr(dimension_tag)} for dimension {dimension_name}"
+                    log.error(f"Could not find dimension_type {':'.join(name_tuple)}")
+
+            elif isinstance(dimension_type, CompoundTag):
+                # Inline type
+                dimension_type_compound = dimension_type
+                min_y = (
+                    dimension_type_compound.get_int("min_y", IntTag()).py_int // 16
+                ) * 16
+                height = (
+                    -dimension_type_compound.get_int("height", IntTag(256)).py_int // 16
+                ) * -16
+                return SelectionGroup(
+                    SelectionBox(
+                        (-30_000_000, min_y, -30_000_000),
+                        (30_000_000, min_y + height, 30_000_000),
                     )
+                )
+            else:
+                log.error(
+                    f'level_dat["Data"]["WorldGenSettings"]["dimensions"]["{dimension_type_str}"]["type"] was not a StringTag or CompoundTag.'
+                )
 
-            self._bounds[dimension_name] = bounds
+        # Return the default if nothing else returned
+        return DefaultSelection
 
     def _get_interface(self, raw_chunk_data: Optional[Any] = None) -> "Interface":
         from amulet.level.loader import Interfaces
@@ -405,9 +420,9 @@ class AnvilFormat(WorldFormatWrapper[VersionNumberInt]):
         self._register_dimension("DIM-1", THE_NETHER)
         self._register_dimension("DIM1", THE_END)
 
-        for dir_name in os.listdir(self.path):
-            level_path = os.path.join(self.path, dir_name)
-            if os.path.isdir(level_path) and dir_name.startswith("DIM"):
+        for level_path in glob.glob(os.path.join(glob.escape(self.path), "DIM*")):
+            if os.path.isdir(level_path):
+                dir_name = os.path.basename(level_path)
                 if AnvilDimensionManager.level_regex.fullmatch(dir_name) is None:
                     continue
                 self._register_dimension(dir_name)

amulet/level/formats/leveldb_world/dimension.py

@@ -8,7 +8,6 @@ from typing import (
     List,
     TYPE_CHECKING,
     Tuple,
-    Union,
 )
 from threading import RLock
 import logging
@@ -25,21 +24,17 @@ from amulet_nbt import (
     utf8_escape_encoder,
 )
 
-from amulet.api.errors import ChunkDoesNotExist, DimensionDoesNotExist
+from amulet.api.errors import ChunkDoesNotExist
 from amulet.api.data_types import ChunkCoordinates
 from leveldb import LevelDB
 from .chunk import ChunkData
 
 if TYPE_CHECKING:
-    from amulet.api.data_types import Dimension
     from .format import LevelDBFormat
 
 log = logging.getLogger(__name__)
 
 InternalDimension = Optional[int]
-OVERWORLD = "minecraft:overworld"
-THE_NETHER = "minecraft:the_nether"
-THE_END = "minecraft:the_end"
 
 
 class ActorCounter:
@@ -102,12 +97,11 @@ class LevelDBDimensionManager:
         self._actor_counter = ActorCounter.from_level(level)
         # self._levels format Dict[level, Dict[Tuple[cx, cz], List[Tuple[full_key, key_extension]]]]
         self._levels: Dict[InternalDimension, Set[ChunkCoordinates]] = {}
-        self._dimension_name_map: Dict["Dimension", InternalDimension] = {}
         self._lock = RLock()
 
-        self.register_dimension(None, OVERWORLD)
-        self.register_dimension(1, THE_NETHER)
-        self.register_dimension(2, THE_END)
+        self.register_dimension(None)  # overworld
+        self.register_dimension(1)  # the nether
+        self.register_dimension(2)  # the end
 
         for key in self._db.keys():
             if 9 <= len(key) <= 10 and key[8] in [44, 118]:  # "," "v"
@@ -117,63 +111,36 @@ class LevelDBDimensionManager:
                 self._add_chunk(key, has_level=True)
 
     @property
-    def dimensions(self) -> List["Dimension"]:
+    def dimensions(self) -> List[InternalDimension]:
         """A list of all the levels contained in the world"""
-        return list(self._dimension_name_map.keys())
+        return list(self._levels)
 
-    def register_dimension(
-        self,
-        dimension_internal: InternalDimension,
-        dimension_name: Optional["Dimension"] = None,
-    ):
+    def register_dimension(self, dimension: InternalDimension):
         """
         Register a new dimension.
 
-        :param dimension_internal: The internal representation of the dimension
-        :param dimension_name: The name of the dimension shown to the user
+        :param dimension: The internal representation of the dimension
         :return:
         """
-        if dimension_name is None:
-            dimension_name: "Dimension" = f"DIM{dimension_internal}"
-
         with self._lock:
-            if (
-                dimension_internal not in self._levels
-                and dimension_name not in self._dimension_name_map
-            ):
-                self._levels[dimension_internal] = set()
-                self._dimension_name_map[dimension_name] = dimension_internal
-
-    def _get_internal_dimension(self, dimension: "Dimension") -> InternalDimension:
-        if dimension in self._dimension_name_map:
-            return self._dimension_name_map[dimension]
-        else:
-            raise DimensionDoesNotExist(dimension)
+            if dimension not in self._levels:
+                self._levels[dimension] = set()
 
-    def all_chunk_coords(self, dimension: "Dimension") -> Set[ChunkCoordinates]:
-        internal_dimension = self._get_internal_dimension(dimension)
-        if internal_dimension in self._levels:
-            return self._levels[internal_dimension]
+    def all_chunk_coords(self, dimension: InternalDimension) -> Set[ChunkCoordinates]:
+        if dimension in self._levels:
+            return self._levels[dimension]
         else:
             return set()
 
     @staticmethod
-    def _get_key(cx: int, cz: int, internal_dimension: InternalDimension) -> bytes:
-        if internal_dimension is None:
+    def _get_key(cx: int, cz: int, dimension: InternalDimension) -> bytes:
+        if dimension is None:
             return struct.pack("<ii", cx, cz)
         else:
-            return struct.pack("<iii", cx, cz, internal_dimension)
-
-    def _has_chunk(
-        self, cx: int, cz: int, internal_dimension: InternalDimension
-    ) -> bool:
-        return (
-            internal_dimension in self._levels
-            and (cx, cz) in self._levels[internal_dimension]
-        )
+            return struct.pack("<iii", cx, cz, dimension)
 
-    def has_chunk(self, cx: int, cz: int, dimension: Dimension) -> bool:
-        return self._has_chunk(cx, cz, self._get_internal_dimension(dimension))
+    def has_chunk(self, cx: int, cz: int, dimension: InternalDimension) -> bool:
+        return dimension in self._levels and (cx, cz) in self._levels[dimension]
 
     def _add_chunk(self, key_: bytes, has_level: bool = False):
         if has_level:
@@ -185,14 +152,15 @@ class LevelDBDimensionManager:
             self.register_dimension(level)
         self._levels[level].add((cx, cz))
 
-    def get_chunk_data(self, cx: int, cz: int, dimension: "Dimension") -> ChunkData:
+    def get_chunk_data(
+        self, cx: int, cz: int, dimension: InternalDimension
+    ) -> ChunkData:
         """Get a dictionary of chunk key extension in bytes to the raw data in the key.
         chunk key extension are the character(s) after <cx><cz>[level] in the key
         Will raise ChunkDoesNotExist if the chunk does not exist
         """
-        internal_dimension = self._get_internal_dimension(dimension)
-        if self._has_chunk(cx, cz, internal_dimension):
-            prefix = self._get_key(cx, cz, internal_dimension)
+        if self.has_chunk(cx, cz, dimension):
+            prefix = self._get_key(cx, cz, dimension)
             prefix_len = len(prefix)
             iter_end = prefix + b"\xff\xff\xff\xff"
 
@@ -288,13 +256,12 @@ class LevelDBDimensionManager:
         cx: int,
         cz: int,
         chunk_data: ChunkData,
-        dimension: "Dimension",
+        dimension: InternalDimension,
     ):
         """pass data to the region file class"""
         # get the region key
-        internal_dimension = self._get_internal_dimension(dimension)
-        self._levels[internal_dimension].add((cx, cz))
-        key_prefix = self._get_key(cx, cz, internal_dimension)
+        self._levels[dimension].add((cx, cz))
+        key_prefix = self._get_key(cx, cz, dimension)
 
         batch = {}
 
@@ -388,15 +355,14 @@ class LevelDBDimensionManager:
         if batch:
             self._db.putBatch(batch)
 
-    def delete_chunk(self, cx: int, cz: int, dimension: "Dimension"):
-        if dimension not in self._dimension_name_map:
+    def delete_chunk(self, cx: int, cz: int, dimension: InternalDimension):
+        if dimension not in self._levels:
             return  # dimension does not exists so chunk cannot
 
-        internal_dimension = self._dimension_name_map[dimension]
-        if not self._has_chunk(cx, cz, internal_dimension):
+        if not self.has_chunk(cx, cz, dimension):
             return  # chunk does not exists
 
-        prefix = self._get_key(cx, cz, internal_dimension)
+        prefix = self._get_key(cx, cz, dimension)
         prefix_len = len(prefix)
         iter_end = prefix + b"\xff\xff\xff\xff"
         keys = []
@@ -414,6 +380,6 @@ class LevelDBDimensionManager:
                 actor_key = b"actorprefix" + digp[i : i + 8]
                 self._db.delete(actor_key)
 
-        self._levels[internal_dimension].remove((cx, cz))
+        self._levels[dimension].remove((cx, cz))
         for key in keys:
             self._db.delete(key)

amulet/level/formats/leveldb_world/format.py

@@ -38,22 +38,23 @@ from amulet.api.data_types import (
     Dimension,
     AnyNDArray,
 )
-from amulet.api.wrapper import WorldFormatWrapper
-from amulet.api.errors import ObjectWriteError, ObjectReadError, PlayerDoesNotExist
+from amulet.api.wrapper import WorldFormatWrapper, DefaultSelection
+from amulet.api.errors import (
+    ObjectWriteError,
+    ObjectReadError,
+    PlayerDoesNotExist,
+    ChunkDoesNotExist,
+)
 
 from .interface.chunk.leveldb_chunk_versions import (
     game_to_chunk_version,
 )
-from .dimension import (
-    LevelDBDimensionManager,
-    ChunkData,
-    OVERWORLD,
-    THE_NETHER,
-    THE_END,
-)
+from .dimension import LevelDBDimensionManager, ChunkData, InternalDimension
 from .interface.chunk import BaseLevelDBInterface, get_interface
 
-InternalDimension = Optional[int]
+OVERWORLD = "minecraft:overworld"
+THE_NETHER = "minecraft:the_nether"
+THE_END = "minecraft:the_end"
 
 
 class BedrockLevelDAT(NamedTag):
@@ -177,6 +178,7 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
             self._root_tag = BedrockLevelDAT(path=dat_path, level_dat_version=9)
         self._db = None
         self._dimension_manager = None
+        self._dimension_to_internal: dict[Dimension, InternalDimension] = {}
         self._shallow_load()
 
     def _shallow_load(self):
@@ -260,12 +262,12 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
             return f"Bedrock Unknown Version"
 
     @property
-    def dimensions(self) -> List["Dimension"]:
+    def dimensions(self) -> List[Dimension]:
         self._verify_has_lock()
-        return self._dimension_manager.dimensions
+        return list(self._dimension_to_internal)
 
     # def register_dimension(
-    #     self, dimension_internal: int, dimension_name: Optional["Dimension"] = None
+    #     self, dimension_internal: int, dimension_name: Optional[Dimension] = None
     # ):
     #     """
     #     Register a new dimension.
@@ -348,6 +350,12 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
             self._dimension_manager = LevelDBDimensionManager(self)
             self._is_open = True
             self._has_lock = True
+
+            self._dimension_to_internal.clear()
+            self._dimension_to_internal[OVERWORLD] = None
+            self._dimension_to_internal[THE_NETHER] = 1
+            self._dimension_to_internal[THE_END] = 2
+
             experiments = self.root_tag.compound.get_compound(
                 "experiments", CompoundTag()
             )
@@ -362,21 +370,14 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
                     )
                 )
             else:
-                self._bounds[OVERWORLD] = SelectionGroup(
-                    SelectionBox(
-                        (-30_000_000, 0, -30_000_000), (30_000_000, 256, 30_000_000)
-                    )
-                )
+                self._bounds[OVERWORLD] = DefaultSelection
             self._bounds[THE_NETHER] = SelectionGroup(
                 SelectionBox(
                     (-30_000_000, 0, -30_000_000), (30_000_000, 128, 30_000_000)
                 )
             )
-            self._bounds[THE_END] = SelectionGroup(
-                SelectionBox(
-                    (-30_000_000, 0, -30_000_000), (30_000_000, 256, 30_000_000)
-                )
-            )
+            self._bounds[THE_END] = DefaultSelection
+
             if b"LevelChunkMetaDataDictionary" in self.level_db:
                 data = self.level_db[b"LevelChunkMetaDataDictionary"]
                 count, data = struct.unpack("<I", data[:4])[0], data[4:]
@@ -396,9 +397,9 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
                         dimension_name = value.get_string("DimensionName").py_str
                         # The dimension names are stored differently TODO: split local and global names
                         dimension_name = {
-                            "Overworld": "minecraft:overworld",
-                            "Nether": "minecraft:the_nether",
-                            "TheEnd": "minecraft:the_end",
+                            "Overworld": OVERWORLD,
+                            "Nether": THE_NETHER,
+                            "TheEnd": THE_END,
                         }.get(dimension_name, dimension_name)
 
                     except KeyError:
@@ -407,13 +408,7 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
                         pass
                     else:
                         previous_bounds = self._bounds.get(
-                            dimension_name,
-                            SelectionGroup(
-                                SelectionBox(
-                                    (-30_000_000, 0, -30_000_000),
-                                    (30_000_000, 256, 30_000_000),
-                                )
-                            ),
+                            dimension_name, DefaultSelection
                         )
                         min_y = min(
                             value.get_compound(
@@ -447,6 +442,15 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
                                 (previous_bounds.max_x, max_y, previous_bounds.max_z),
                             )
                         )
+
+            # Give all other dimensions found an entry
+            known_dimensions = set(self._dimension_to_internal.values())
+            for internal_dimension in self._dimension_manager.dimensions:
+                if internal_dimension not in known_dimensions:
+                    dimension_name = f"DIM{internal_dimension}"
+                    self._dimension_to_internal[dimension_name] = internal_dimension
+                    self._bounds[dimension_name] = DefaultSelection
+
         except LevelDBEncrypted as e:
             self._is_open = self._has_lock = False
             raise LevelDBException(
@@ -525,24 +529,34 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
     def unload(self):
         pass
 
-    def all_chunk_coords(self, dimension: "Dimension") -> Iterable[ChunkCoordinates]:
+    def all_chunk_coords(self, dimension: Dimension) -> Iterable[ChunkCoordinates]:
         self._verify_has_lock()
-        yield from self._dimension_manager.all_chunk_coords(dimension)
+        if dimension in self._dimension_to_internal:
+            yield from self._dimension_manager.all_chunk_coords(
+                self._dimension_to_internal[dimension]
+            )
 
     def has_chunk(self, cx: int, cz: int, dimension: Dimension) -> bool:
-        return self._dimension_manager.has_chunk(cx, cz, dimension)
+        if dimension in self._dimension_to_internal:
+            return self._dimension_manager.has_chunk(
+                cx, cz, self._dimension_to_internal[dimension]
+            )
+        return False
 
-    def _delete_chunk(self, cx: int, cz: int, dimension: "Dimension"):
-        self._dimension_manager.delete_chunk(cx, cz, dimension)
+    def _delete_chunk(self, cx: int, cz: int, dimension: Dimension):
+        if dimension in self._dimension_to_internal:
+            self._dimension_manager.delete_chunk(
+                cx, cz, self._dimension_to_internal[dimension]
+            )
 
     def _put_raw_chunk_data(
-        self, cx: int, cz: int, data: ChunkData, dimension: "Dimension"
+        self, cx: int, cz: int, data: ChunkData, dimension: Dimension
     ):
-        return self._dimension_manager.put_chunk_data(cx, cz, data, dimension)
+        self._dimension_manager.put_chunk_data(
+            cx, cz, data, self._dimension_to_internal[dimension]
+        )
 
-    def _get_raw_chunk_data(
-        self, cx: int, cz: int, dimension: "Dimension"
-    ) -> ChunkData:
+    def _get_raw_chunk_data(self, cx: int, cz: int, dimension: Dimension) -> ChunkData:
         """
         Return the raw data as loaded from disk.
 
@@ -551,7 +565,11 @@ class LevelDBFormat(WorldFormatWrapper[VersionNumberTuple]):
         :param dimension: The dimension to load the data from.
         :return: The raw chunk data.
         """
-        return self._dimension_manager.get_chunk_data(cx, cz, dimension)
+        if dimension not in self._dimension_to_internal:
+            raise ChunkDoesNotExist
+        return self._dimension_manager.get_chunk_data(
+            cx, cz, self._dimension_to_internal[dimension]
+        )
 
     def all_player_ids(self) -> Iterable[str]:
         """

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

@@ -13,7 +13,7 @@ class Anvil3463Interface(ParentInterface):
 
     @staticmethod
     def minor_is_valid(key: int):
-        return 3454 <= key < 3480
+        return 3454 <= key < 3580
 
 
 export = Anvil3463Interface

{amulet_core-1.9.18.dist-info → amulet_core-1.9.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amulet-core
-Version: 1.9.18
+Version: 1.9.20
 Summary: A Python library for reading/writing Minecraft's various save formats.
 Home-page: https://www.amuletmc.com
 Author: James Clare, Ben Gothard et al.
@@ -8,7 +8,7 @@ Author-email: amuleteditor@gmail.com
 Platform: any
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: numpy ~=1.17
 Requires-Dist: amulet-nbt ~=2.0

{amulet_core-1.9.18.dist-info → amulet_core-1.9.20.dist-info}/RECORD

@@ -1,5 +1,5 @@
 amulet/__init__.py,sha256=sWKAqhofjzTINMJB22nXeBTITznt4H9rM3ZaaAn2SB4,866
-amulet/_version.py,sha256=7ltudBUYV8pYhsEK96sAh2VaaPGef3MmuO8byq_bRfU,498
+amulet/_version.py,sha256=gUdgVfmYy5twLboNe4_FGwrJzp6s23bhMPNOnXdLQJQ,498
 amulet/__pyinstaller/__init__.py,sha256=JJOm9J0BoU_vwoYyoHgd8vwSdiO5SGlHHWH6EQK6sc4,41
 amulet/__pyinstaller/hook-amulet.py,sha256=5s6LZxxd47zNsrsJi-PORR7Q6QC079D7pcTkSn1uzCs,158
 amulet/api/__init__.py,sha256=HJ88KU13JNYES9sptkz0la0OsoRvBGUavuOanaZ_RyM,46
@@ -43,7 +43,7 @@ amulet/api/level/__init__.py,sha256=w-tIez-d-wurUHaxYijjeIPXF3MaV6d5IHEZQo0z5Gg,
 amulet/api/level/structure.py,sha256=jbcCaaZOoY8cwUxbSKu8R9Zq2HYdPLgiFSYBzoD2OSM,619
 amulet/api/level/world.py,sha256=HpKe4uvV5Ar2RaNf59wuP5tsxJmComMMNHpnjYAT7_Y,613
 amulet/api/level/base_level/__init__.py,sha256=Gix697NJxsR4zuYf-Q5Rj2IgrWWMpKvqQTfSc4TVuEY,34
-amulet/api/level/base_level/base_level.py,sha256=xX3izpmgREj-FevtFPaHA3ZvlmoFFDlYAQrYVc3hdc8,43105
+amulet/api/level/base_level/base_level.py,sha256=Sfd0Qgu-xGasJO9aLpMFmf68DjMSt6J3w6nmTIsOcSU,43619
 amulet/api/level/base_level/chunk_manager.py,sha256=Dru933TSAmH3bklVulVvwxyp4VGFa2CHZvjmkDzmLZM,8921
 amulet/api/level/base_level/clone.py,sha256=1CxmXha7i6Vlz7QOUY4K3q3zbd6l0SqF-ppvB12VHvc,19543
 amulet/api/level/base_level/player_manager.py,sha256=ecx4AXAWGxuVG5zaQ_lS2Mr-O0VQu685n3KneTkV4nA,3226
@@ -78,9 +78,9 @@ amulet/level/loader.py,sha256=WF8LrPY8S9qAUIEse4FMkb7EDc0DzqNGs1graykj0-c,2869
 amulet/level/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amulet/level/formats/anvil_forge_world.py,sha256=oktfFzj7YYzCdpHJeRKPp-XAR6EzGIp9nHeaQSvUHGo,1187
 amulet/level/formats/anvil_world/__init__.py,sha256=QlLF_96Ub9ceibhR8J1CVfkSaAqXl8dUQWWxFjDJkW0,54
-amulet/level/formats/anvil_world/_sector_manager.py,sha256=YKvTlbGlJuX4oBYFGuwVklgS8fvoEjQh9WtFugnD5f4,12660
+amulet/level/formats/anvil_world/_sector_manager.py,sha256=QK-M9C4j_QfcpBxd_GwmUeQbwpnTgc6TC6egqtB4ZP8,11080
 amulet/level/formats/anvil_world/dimension.py,sha256=Ft38XWSjJ7mRjHqF-XjEIR7uJFTB_oBaWQIPNaMrsgQ,6069
-amulet/level/formats/anvil_world/format.py,sha256=LgUUM_D5e2sADlawj7rbf2LCVh_I7pixAHVnHhvsiaQ,27187
+amulet/level/formats/anvil_world/format.py,sha256=FYcBhiKw_kRb5yKLtFkTD-kqlYDsZTXN72snBgjmstI,27502
 amulet/level/formats/anvil_world/region.py,sha256=-_Ru3na9SJsUWQhzRGOb1uTLoIbg2mdpVUNIa2-TM14,14095
 amulet/level/formats/anvil_world/data_pack/__init__.py,sha256=L-He67mqDNWp0boI1VDyIz92BfBZqSKLnBcR0bYxQUA,79
 amulet/level/formats/anvil_world/data_pack/data_pack.py,sha256=N7WwzdQuqmIsjInIqhk-I0UGV67wCFc_ysQMYh0UXYU,6161
@@ -92,8 +92,8 @@ amulet/level/formats/construction/section.py,sha256=_LdEQTLpaWnFhFCsmrzEFKRvXl7k
 amulet/level/formats/construction/util.py,sha256=dBBITNfxUocxxzVnUpRUetr0KuLtMVGjk0-o6iAUKBs,4930
 amulet/level/formats/leveldb_world/__init__.py,sha256=dXo6jIok-_suB3KSrhb5NZS7CicGQj-HCLiGpD76QDY,58
 amulet/level/formats/leveldb_world/chunk.py,sha256=iNMwNs09Kyj9fUo3dFZxdtLyW_uh11aXgDUqe_MKoQo,1202
-amulet/level/formats/leveldb_world/dimension.py,sha256=mPBChZNH4ujn-n4__vfC1YuR_ZXUajFqek_B40w6ZA8,16304
-amulet/level/formats/leveldb_world/format.py,sha256=gbrBR7iidRaTUNnT5bp35VLFaTZSe2cxOIKeWlQW9Bk,22614
+amulet/level/formats/leveldb_world/dimension.py,sha256=MDnPlQd5LYEJyd9Z9B_-bsbfCkOqQsoTZfEfrxVwupA,14726
+amulet/level/formats/leveldb_world/format.py,sha256=PsnpNE778q83wKw_6bbH06V9Q1avIpyh3U8pj0iTMlw,23401
 amulet/level/formats/leveldb_world/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 amulet/level/formats/leveldb_world/interface/chunk/__init__.py,sha256=S606IgGmRqdQfv223yciHil3qqna8r5DiW8gsrNHyf0,1180
 amulet/level/formats/leveldb_world/interface/chunk/base_leveldb_interface.py,sha256=3SvaZX_2Umi3ibfD9zVo6pn6vnnJ34NQOJ51oDB8JRs,32470
@@ -174,7 +174,7 @@ amulet/level/interfaces/chunk/anvil/anvil_2529.py,sha256=UTtQkxcM3jUdSWpy02gehEh
 amulet/level/interfaces/chunk/anvil/anvil_2681.py,sha256=w9lz9014E3yNFdsLUFvF4UP1IE_OzdwFp8lZ0Zl5tCg,2319
 amulet/level/interfaces/chunk/anvil/anvil_2709.py,sha256=qRvOb67bjyh-HcSEUiqlf1YKMqPfZjeW98Aid92YQy8,417
 amulet/level/interfaces/chunk/anvil/anvil_2844.py,sha256=0jqoRhw5kRgDUfmm6dF18lxpIsDvm0eSL2rckVFhCCY,10216
-amulet/level/interfaces/chunk/anvil/anvil_3463.py,sha256=h8X-p5rPIHuGDBD3YuZGfMR2-kmpAIVdo193H6Wh2mY,422
+amulet/level/interfaces/chunk/anvil/anvil_3463.py,sha256=vin45VuAiRsLhM03n6Sl527-O28fiiwIiTBwE3gklx4,422
 amulet/level/interfaces/chunk/anvil/anvil_na.py,sha256=9E9Jd9sQQqG_osfYmIg50hbMpZ0c9Dhi1N1ZDurC2VI,22007
 amulet/level/interfaces/chunk/anvil/base_anvil_interface.py,sha256=fG3nEkRxY9O-yvlBPFJW1abTb8Vw6Lhh7rjMJf7c1SA,11979
 amulet/level/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -201,8 +201,8 @@ amulet/utils/generator.py,sha256=2pKToghl8irYozX5hBJYtjTQVzhljznPCi42hQKRGDQ,364
 amulet/utils/matrix.py,sha256=KSqluO0H6oHUfe0pU4Esv67pOmHFurK2BDOrZAeNxg8,7665
 amulet/utils/numpy_helpers.py,sha256=fM0rjZxbUqoTMTrFooZEVVhHfsqv0j_7KPGsjVq4ReM,1232
 amulet/utils/world_utils.py,sha256=xb6JPrrbwDF0_y4ZYjTJ1ieydL3COzzLosTgcxDDyRc,12559
-amulet_core-1.9.18.dist-info/METADATA,sha256=RMOLRl_xYFXWn08XRO8PwnSydbRQtIXANohhjQbbybQ,4262
-amulet_core-1.9.18.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-amulet_core-1.9.18.dist-info/entry_points.txt,sha256=53zFNThTPzI8f9ertsyU2DoUpxdWU8rjOA_Cu4YH5Vk,63
-amulet_core-1.9.18.dist-info/top_level.txt,sha256=3ZqHzNDiIb9kV8TwSeeXxK_9haSrsu631Qe4ndDo0rc,7
-amulet_core-1.9.18.dist-info/RECORD,,
+amulet_core-1.9.20.dist-info/METADATA,sha256=SYeHecDnCp-awuJ5JkzMoHmIWRQMVm5RhR81LTzCfo0,4262
+amulet_core-1.9.20.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+amulet_core-1.9.20.dist-info/entry_points.txt,sha256=53zFNThTPzI8f9ertsyU2DoUpxdWU8rjOA_Cu4YH5Vk,63
+amulet_core-1.9.20.dist-info/top_level.txt,sha256=3ZqHzNDiIb9kV8TwSeeXxK_9haSrsu631Qe4ndDo0rc,7
+amulet_core-1.9.20.dist-info/RECORD,,