amulet-core 2.0a5__cp311-cp311-macosx_10_9_universal2.whl

amulet/level/java/anvil/_sector_manager.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from typing import NamedTuple
+import threading
+from bisect import bisect_left, bisect_right
+
+
+class NoValidSector(Exception):
+    """An error for when there is no sector large enough and the region cannot be resized."""
+
+    pass
+
+
+class Sector(NamedTuple):
+    start: int
+    stop: int
+
+    @property
+    def length(self) -> int:
+        return self.stop - self.start
+
+    def intersects(self, other: Sector) -> bool:
+        """Do the two sectors intersect each other."""
+        return not (other.stop <= self.start or self.stop <= other.start)
+
+    def contains(self, other: Sector) -> bool:
+        """Is the other sector entirely within this sector."""
+        return self.start <= other.start and other.stop <= self.stop
+
+    def neighbours(self, other: Sector) -> bool:
+        """Do the two sectors neighbour but not intersect."""
+        return other.stop == self.start or self.stop == other.start
+
+    def split(self, other: Sector) -> list[Sector]:
+        """
+        Split this sector around another sector.
+        The other sector must be contained within this sector
+
+        :param other: The other sector to split around.
+        :return: A list of 0-2 sectors
+        """
+        sectors = []
+        if self.start < other.start:
+            sectors.append(Sector(self.start, other.start))
+        if other.stop < self.stop:
+            sectors.append(Sector(other.stop, self.stop))
+        return sectors
+
+
+class SectorManager:
+    """A class to manage a sequence of memory."""
+
+    def __init__(self, start: int, stop: int, resizable: bool = True):
+        """
+        :param start: The start of the memory region
+        :param stop: The end of the memory region
+        :param resizable: Can the region be resized
+        """
+        if stop < start:
+            raise ValueError("stop must be at least start")
+        self._lock = threading.RLock()
+        self._stop = stop
+        self._resizable = resizable
+
+        # A list of free sectors ordered by start location
+        self._free_start = [Sector(start, stop)]
+        # A list of free sectors ordered by (length, start).
+        # This makes it easier to find the first sector large enough
+        self._free_size = [Sector(start, stop)]
+
+        # A set of reserved sectors
+        self._reserved: set[Sector] = set()
+
+    @property
+    def sectors(self) -> list[Sector]:
+        """A list of reserved sectors. Ordered by their start location."""
+        with self._lock:
+            return list(sorted(self._reserved, key=lambda i: i.start))
+
+    def reserve_space(self, length: int) -> Sector:
+        """
+        Find and reserve a memory location large enough to fit the requested memory.
+
+        :param length: The length of the memory region to reserve
+        :return: The index of the start of the reserved memory region
+        """
+        if not length:
+            raise ValueError("Cannot reserve a sector with zero length.")
+        with self._lock:
+            # find the index of the first element with a larger or equal length prioritising the ones closer to the start
+            index = bisect_left(
+                self._free_size, (length, 0), key=lambda k: (k.length, k.start)
+            )
+            if index < len(self._free_size):
+                # if there exists a section large enough to fit the length
+                free_sector = self._free_size.pop(index)
+                start_index = self._free_start.index(free_sector)
+                sector = Sector(free_sector.start, free_sector.start + length)
+                if free_sector.length > length:
+                    free_sector = Sector(sector.stop, free_sector.stop)
+                    self._add_size_sector(free_sector)
+                    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)
+                self._stop = sector.stop
+                self._reserved.add(sector)
+                return sector
+            else:
+                raise NoValidSector(
+                    "There is not enough contiguous space to allocate the length."
+                )
+
+    def reserve(self, sector: Sector) -> None:
+        """
+        Mark a section as reserved.
+        If you don't know exactly where the sector is use `reserve_space` to find and reserve a new sector
+
+        :param sector: The sector to reserve
+        """
+        if not sector.length:
+            raise ValueError("Cannot reserve a sector with zero length.")
+        with self._lock:
+            if sector.start >= self._stop and (
+                not self._free_start or self._free_start[-1].stop != self._stop
+            ):
+                if self._resizable:
+                    # if the last sector has been reserved or did not exist then create a new one
+                    s = Sector(self._stop, sector.stop)
+                    self._free_start.append(s)
+                    self._add_size_sector(s)
+                    self._stop = sector.stop
+                else:
+                    raise NoValidSector("The sector starts outside of the region.")
+
+            # Get the index of the segment with the latest start point that is
+            # less than or equal to the start point of the sector being reserved.
+            index = (
+                bisect_right(self._free_start, sector.start, key=lambda k: k.start) - 1
+            )
+
+            if index < 0:
+                raise NoValidSector(
+                    "No free sectors that start at or before the one being reserved."
+                )
+
+            free_sector = self._free_start[index]
+
+            if sector.stop <= free_sector.stop:
+                # The sector fits within the contained sector
+                # remove the contained sector from the lists
+                del self._free_start[index]
+                self._free_size.remove(free_sector)
+            elif free_sector.stop == self._stop:
+                if self._resizable:
+                    # The sector is the last one and the memory region is resizable
+                    del self._free_start[index]
+                    self._free_size.remove(free_sector)
+                    free_sector = Sector(free_sector.start, sector.stop)
+                    self._stop = sector.stop
+                else:
+                    raise NoValidSector(
+                        "The sector is outside the defined region and the region is not resizable."
+                    )
+            else:
+                raise NoValidSector("The requested sector is not free to be reserved.")
+
+            # split around the reserved sector
+            sectors = free_sector.split(sector)
+            # add the results back
+            self._free_start[index:index] = sectors
+            for s in sectors:
+                self._add_size_sector(s)
+            self._reserved.add(sector)
+
+    def _add_size_sector(self, sector: Sector) -> None:
+        self._free_size.insert(
+            bisect_left(
+                self._free_size,
+                (sector.length, sector.start),
+                key=lambda k: (k.length, k.start),
+            ),
+            sector,
+        )
+
+    def free(self, sector: Sector) -> None:
+        """
+        Free a reserved sector.
+        The sector must match exactly a sector previously reserved.
+
+        :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)
+
+            # Add it back to the free storage
+            # find the position where it would be placed in the list ordered by start location
+            index = bisect_right(self._free_start, sector.start, key=lambda k: k.start)
+
+            # merge with the right neighbour
+            if (
+                index < len(self._free_start)
+                and self._free_start[index].start == sector.stop
+            ):
+                right_sector = self._free_start.pop(index)
+                self._free_size.remove(right_sector)
+                sector = Sector(sector.start, right_sector.stop)
+
+            # merge with the left neighbour
+            if index > 0 and self._free_start[index - 1].stop == sector.start:
+                left_sector = self._free_start.pop(index - 1)
+                self._free_size.remove(left_sector)
+                sector = Sector(left_sector.start, sector.stop)
+                index -= 1
+
+            self._free_start.insert(index, sector)
+            self._add_size_sector(sector)

amulet/level/java/anvil/_sector_manager.pyi

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import threading as threading
+import typing
+from typing import NamedTuple
+
+from _bisect import bisect_left, bisect_right
+
+__all__ = [
+    "NamedTuple",
+    "NoValidSector",
+    "Sector",
+    "SectorManager",
+    "bisect_left",
+    "bisect_right",
+    "threading",
+]
+
+class NoValidSector(Exception):
+    """
+    An error for when there is no sector large enough and the region cannot be resized.
+    """
+
+class Sector(tuple):
+    """
+    Sector(start, stop)
+    """
+
+    __slots__: typing.ClassVar[tuple] = tuple()
+    _field_defaults: typing.ClassVar[dict] = {}
+    _fields: typing.ClassVar[tuple] = ("start", "stop")
+    @staticmethod
+    def __new__(_cls, start: ForwardRef("int"), stop: ForwardRef("int")):
+        """
+        Create new instance of Sector(start, stop)
+        """
+
+    @classmethod
+    def _make(cls, iterable):
+        """
+        Make a new Sector object from a sequence or iterable
+        """
+
+    def __getnewargs__(self):
+        """
+        Return self as a plain tuple.  Used by copy and pickle.
+        """
+
+    def __repr__(self):
+        """
+        Return a nicely formatted representation string
+        """
+
+    def _asdict(self):
+        """
+        Return a new dict which maps field names to their values.
+        """
+
+    def _replace(self, **kwds):
+        """
+        Return a new Sector object replacing specified fields with new values
+        """
+
+    def contains(self, other: Sector) -> bool:
+        """
+        Is the other sector entirely within this sector.
+        """
+
+    def intersects(self, other: Sector) -> bool:
+        """
+        Do the two sectors intersect each other.
+        """
+
+    def neighbours(self, other: Sector) -> bool:
+        """
+        Do the two sectors neighbour but not intersect.
+        """
+
+    def split(self, other: Sector) -> list[Sector]:
+        """
+
+        Split this sector around another sector.
+        The other sector must be contained within this sector
+
+        :param other: The other sector to split around.
+        :return: A list of 0-2 sectors
+
+        """
+
+    @property
+    def length(self) -> int: ...
+
+class SectorManager:
+    """
+    A class to manage a sequence of memory.
+    """
+
+    def __init__(self, start: int, stop: int, resizable: bool = True):
+        """
+
+        :param start: The start of the memory region
+        :param stop: The end of the memory region
+        :param resizable: Can the region be resized
+
+        """
+
+    def _add_size_sector(self, sector: Sector) -> None: ...
+    def free(self, sector: Sector) -> None:
+        """
+
+        Free a reserved sector.
+        The sector must match exactly a sector previously reserved.
+
+        :param sector: The sector to free
+
+        """
+
+    def reserve(self, sector: Sector) -> None:
+        """
+
+        Mark a section as reserved.
+        If you don't know exactly where the sector is use `reserve_space` to find and reserve a new sector
+
+        :param sector: The sector to reserve
+
+        """
+
+    def reserve_space(self, length: int) -> Sector:
+        """
+
+        Find and reserve a memory location large enough to fit the requested memory.
+
+        :param length: The length of the memory region to reserve
+        :return: The index of the start of the reserved memory region
+
+        """
+
+    @property
+    def sectors(self) -> list[Sector]:
+        """
+        A list of reserved sectors. Ordered by their start location.
+        """

amulet/level/java/chunk.pyi

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import amulet.biome
+import amulet.block
+import amulet.chunk
+import amulet.chunk_components
+import amulet.level.java.chunk_components
+
+__all__ = [
+    "JavaChunk",
+    "JavaChunk0",
+    "JavaChunk1444",
+    "JavaChunk1466",
+    "JavaChunk2203",
+    "JavaChunkNA",
+]
+
+class JavaChunk(amulet.chunk.Chunk):
+    pass
+
+class JavaChunk0(
+    JavaChunk,
+    amulet.level.java.chunk_components.JavaRawChunkComponent,
+    amulet.level.java.chunk_components.DataVersionComponent,
+    amulet.chunk_components.BlockComponent,
+):
+    def __init__(
+        self,
+        data_version: int,
+        default_block: amulet.block.BlockStack,
+        default_biome: amulet.biome.Biome,
+    ) -> None: ...
+
+class JavaChunk1444(
+    JavaChunk,
+    amulet.level.java.chunk_components.JavaRawChunkComponent,
+    amulet.level.java.chunk_components.DataVersionComponent,
+    amulet.chunk_components.BlockComponent,
+):
+    def __init__(
+        self,
+        data_version: int,
+        default_block: amulet.block.BlockStack,
+        default_biome: amulet.biome.Biome,
+    ) -> None: ...
+
+class JavaChunk1466(
+    JavaChunk,
+    amulet.level.java.chunk_components.JavaRawChunkComponent,
+    amulet.level.java.chunk_components.DataVersionComponent,
+    amulet.chunk_components.BlockComponent,
+):
+    def __init__(
+        self,
+        data_version: int,
+        default_block: amulet.block.BlockStack,
+        default_biome: amulet.biome.Biome,
+    ) -> None: ...
+
+class JavaChunk2203(
+    JavaChunk,
+    amulet.level.java.chunk_components.JavaRawChunkComponent,
+    amulet.level.java.chunk_components.DataVersionComponent,
+    amulet.chunk_components.BlockComponent,
+):
+    def __init__(
+        self,
+        data_version: int,
+        default_block: amulet.block.BlockStack,
+        default_biome: amulet.biome.Biome,
+    ) -> None: ...
+
+class JavaChunkNA(
+    JavaChunk,
+    amulet.level.java.chunk_components.JavaRawChunkComponent,
+    amulet.level.java.chunk_components.DataVersionComponent,
+    amulet.chunk_components.BlockComponent,
+):
+    def __init__(
+        self, default_block: amulet.block.BlockStack, default_biome: amulet.biome.Biome
+    ) -> None: ...

amulet/level/java/chunk_/_chunk.py

@@ -0,0 +1,260 @@
+# from typing import Self, TypeAlias, cast
+# from types import UnionType
+#
+# import numpy
+#
+# from amulet.version import VersionRange, VersionNumber
+# from amulet.block import BlockStack, Block
+# from amulet.biome import Biome
+#
+# from amulet.chunk import Chunk, ComponentDataMapping
+# from amulet.chunk.components.height_2d import Height2DComponent
+# from amulet.chunk.components.biome import (
+#     Biome2DComponent,
+#     Biome2DComponentData,
+#     Biome3DComponent,
+#     Biome3DComponentData,
+# )
+# from amulet.chunk.components.block import BlockComponent, BlockComponentData
+# from amulet.chunk.components.block_entity import (
+#     BlockEntityComponent,
+#     BlockEntityComponentData,
+# )
+# from amulet.chunk.components.entity import EntityComponent, EntityComponentData
+# from amulet.level.java.chunk.components.raw_chunk import RawChunkComponent
+# from amulet.level.java.chunk.components.data_version import DataVersionComponent
+# from amulet.level.java.chunk.components.legacy_version import LegacyVersionComponent
+# from amulet.level.java.chunk.components.status import StatusComponent
+# from amulet.level.java.chunk.components.light_populated import LightPopulatedComponent
+# from amulet.level.java.chunk.components.terrain_populated import (
+#     TerrainPopulatedComponent,
+# )
+# from amulet.level.java.chunk.components.named_height_2d import (
+#     NamedHeight2DComponent,
+#     NamedHeight2DData,
+# )
+# from amulet.level.java.chunk.components.last_update import LastUpdateComponent
+#
+#
+# def _get_components(
+#     data_version: int, default_block: BlockStack, default_biome: Biome
+# ) -> ComponentDataMapping:
+#     components: ComponentDataMapping = {}  # type: ignore
+#
+#     version_range = VersionRange(
+#         "java", VersionNumber(data_version), VersionNumber(data_version)
+#     )
+#
+#     components[RawChunkComponent] = None
+#     components[DataVersionComponent] = data_version
+#     components[LastUpdateComponent] = 0
+#
+#     if data_version == -1:
+#         components[LegacyVersionComponent] = 1
+#     if data_version >= 3454:
+#         components[StatusComponent] = "minecraft:full"
+#     elif data_version >= 1912:
+#         components[StatusComponent] = "full"
+#     elif data_version >= 1444:
+#         components[StatusComponent] = "postprocessed"
+#     else:
+#         components[TerrainPopulatedComponent] = True
+#         components[LightPopulatedComponent] = True
+#
+#     components[BlockComponent] = BlockComponentData(
+#         version_range, (16, 16, 16), default_block
+#     )
+#     components[BlockEntityComponent] = BlockEntityComponentData(version_range)
+#     components[EntityComponent] = EntityComponentData(version_range)
+#
+#     if data_version >= 2203:
+#         components[Biome3DComponent] = Biome3DComponentData(
+#             version_range, (4, 4, 4), default_biome
+#         )
+#     else:
+#         components[Biome2DComponent] = Biome2DComponentData(
+#             version_range, (16, 16), default_biome
+#         )
+#
+#     if data_version >= 1908:
+#         components[NamedHeight2DComponent] = NamedHeight2DData(
+#             (16, 16),
+#             {
+#                 key: numpy.zeros((16, 16), dtype=numpy.int64)
+#                 for key in (
+#                     "WORLD_SURFACE_WG",
+#                     "OCEAN_FLOOR_WG",
+#                     "MOTION_BLOCKING",
+#                     "MOTION_BLOCKING_NO_LEAVES",
+#                     "OCEAN_FLOOR",
+#                     "WORLD_SURFACE",
+#                 )
+#             },
+#         )
+#     if data_version >= 1503:
+#         components[NamedHeight2DComponent] = NamedHeight2DData(
+#             (16, 16),
+#             {
+#                 key: numpy.zeros((16, 16), dtype=numpy.int64)
+#                 for key in (
+#                     "WORLD_SURFACE_WG",
+#                     "OCEAN_FLOOR_WG",
+#                     "MOTION_BLOCKING",
+#                     "MOTION_BLOCKING_NO_LEAVES",
+#                     "OCEAN_FLOOR",
+#                     "LIGHT_BLOCKING",
+#                     "WORLD_SURFACE",
+#                 )
+#             },
+#         )
+#     if data_version >= 1484:
+#         components[NamedHeight2DComponent] = NamedHeight2DData(
+#             (16, 16),
+#             {
+#                 key: numpy.zeros((16, 16), dtype=numpy.int64)
+#                 for key in (
+#                     "WORLD_SURFACE_WG",
+#                     "OCEAN_FLOOR_WG",
+#                     "MOTION_BLOCKING",
+#                     "MOTION_BLOCKING_NO_LEAVES",
+#                     "OCEAN_FLOOR",
+#                     "LIGHT_BLOCKING",
+#                 )
+#             },
+#         )
+#     if data_version >= 1466:
+#         components[NamedHeight2DComponent] = NamedHeight2DData(
+#             (16, 16),
+#             {
+#                 key: numpy.zeros((16, 16), dtype=numpy.int64)
+#                 for key in ("LIQUID", "SOLID", "LIGHT", "RAIN")
+#             },
+#         )
+#     else:
+#         components[Height2DComponent] = numpy.zeros((16, 16), dtype=numpy.int64)
+#
+#     return components
+#
+#
+# class JavaChunkNA(Chunk):
+#     components = frozenset(
+#         _get_components(
+#             -1,
+#             BlockStack(Block("java", VersionNumber(-1), "", "")),
+#             Biome("java", VersionNumber(-1), "", ""),
+#         )
+#     )
+#
+#     @classmethod
+#     def new(cls, default_block: BlockStack, default_biome: Biome) -> Self:
+#         self = cls.from_component_data(
+#             _get_components(-1, default_block, default_biome)
+#         )
+#         return self
+#
+#
+# class JavaChunk0(Chunk):
+#     """Added DataVersion"""
+#
+#     components = frozenset(
+#         _get_components(
+#             0,
+#             BlockStack(Block("java", VersionNumber(0), "", "")),
+#             Biome("java", VersionNumber(0), "", ""),
+#         )
+#     )
+#
+#     @classmethod
+#     def new(
+#         cls, data_version: int, default_block: BlockStack, default_biome: Biome
+#     ) -> Self:
+#         if not 0 <= data_version < 1444:
+#             raise ValueError("data version must be between 0 and 1443")
+#         self = cls.from_component_data(
+#             _get_components(data_version, default_block, default_biome)
+#         )
+#         return self
+#
+#
+# class JavaChunk1444(Chunk):
+#     """
+#     Moved TerrainPopulated and LightPopulated to Status
+#     Made blocks paletted
+#     Added more tick tags
+#     Added structures tag
+#     """
+#
+#     components = frozenset(
+#         _get_components(
+#             1444,
+#             BlockStack(Block("java", VersionNumber(1444), "", "")),
+#             Biome("java", VersionNumber(1444), "", ""),
+#         )
+#     )
+#
+#     @classmethod
+#     def new(
+#         cls, data_version: int, default_block: BlockStack, default_biome: Biome
+#     ) -> Self:
+#         if not 1444 <= data_version < 1466:
+#             raise ValueError("data version must be between 1444 and 1465")
+#         self = cls.from_component_data(
+#             _get_components(data_version, default_block, default_biome)
+#         )
+#         return self
+#
+#
+# class JavaChunk1466(Chunk):
+#     """
+#     Added multiple height maps. Now stored in a compound.
+#     """
+#
+#     components = frozenset(
+#         _get_components(
+#             1466,
+#             BlockStack(Block("java", VersionNumber(1466), "", "")),
+#             Biome("java", VersionNumber(1466), "", ""),
+#         )
+#     )
+#
+#     @classmethod
+#     def new(
+#         cls, data_version: int, default_block: BlockStack, default_biome: Biome
+#     ) -> Self:
+#         if not 1466 <= data_version < 2203:
+#             raise ValueError("data version must be between 1466 and 2202")
+#         self = cls.from_component_data(
+#             _get_components(data_version, default_block, default_biome)
+#         )
+#         return self
+#
+#
+# class JavaChunk2203(Chunk):
+#     """
+#     Made biomes 3D
+#     """
+#
+#     components = frozenset(
+#         _get_components(
+#             2203,
+#             BlockStack(Block("java", VersionNumber(2203), "", "")),
+#             Biome("java", VersionNumber(2203), "", ""),
+#         )
+#     )
+#
+#     @classmethod
+#     def new(
+#         cls, data_version: int, default_block: BlockStack, default_biome: Biome
+#     ) -> Self:
+#         if not 2203 <= data_version:
+#             raise ValueError("data version must be at least 2203")
+#         self = cls.from_component_data(
+#             _get_components(data_version, default_block, default_biome)
+#         )
+#         return self
+#
+#
+# # TODO: Improve this if python/mypy#11673 gets fixed.
+# JavaChunk: TypeAlias = cast(
+#     UnionType, JavaChunkNA | JavaChunk0 | JavaChunk1444 | JavaChunk1466 | JavaChunk2203
+# )