amulet-core 1.9.18__tar.gz → 1.9.20__tar.gz

{amulet-core-1.9.18 → amulet-core-1.9.20}/PKG-INFO

@@ -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,10 +8,21 @@ 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
+Requires-Dist: pymctranslate~=1.2
+Requires-Dist: portalocker~=2.4
+Requires-Dist: amulet-leveldb~=1.0b0
+Requires-Dist: platformdirs~=3.1
 Provides-Extra: docs
+Requires-Dist: Sphinx>=1.7.4; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.3.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=0.3.1; extra == "docs"
 Provides-Extra: dev
+Requires-Dist: black>=22.3; extra == "dev"
+Requires-Dist: pre_commit>=1.11.1; extra == "dev"
 
 # Amulet Core
 

{amulet-core-1.9.18 → amulet-core-1.9.20}/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-core-1.9.18 → amulet-core-1.9.20}/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-core-1.9.18 → amulet-core-1.9.20}/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-core-1.9.18 → amulet-core-1.9.20}/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-core-1.9.18 → amulet-core-1.9.20}/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)