amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp312-cp312-win_amd64.whl

amulet/level/java/anvil/_sector_manager.py

@@ -1,223 +0,0 @@
-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/chunk.pyi

@@ -1,81 +0,0 @@
-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

@@ -1,260 +0,0 @@
-# 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
-# )

amulet/level/java/chunk_/components/inhabited_time.py

@@ -1,12 +0,0 @@
-# from __future__ import annotations
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class InhabitedTimeComponent(ChunkComponent[int, int]):
-#     storage_key = b"jit"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: int, new_obj: int) -> int:
-#         if not isinstance(new_obj, int):
-#             raise TypeError
-#         return new_obj

amulet/level/java/chunk_/components/last_update.py

@@ -1,12 +0,0 @@
-# from __future__ import annotations
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class LastUpdateComponent(ChunkComponent[int, int]):
-#     storage_key = b"jlu"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: int, new_obj: int) -> int:
-#         if not isinstance(new_obj, int):
-#             raise TypeError
-#         return new_obj

amulet/level/java/chunk_/components/legacy_version.py

@@ -1,12 +0,0 @@
-# from __future__ import annotations
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class LegacyVersionComponent(ChunkComponent[int, int]):
-#     storage_key = b"jlv"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: int, new_obj: int) -> int:
-#         if not isinstance(new_obj, int):
-#             raise TypeError
-#         return new_obj

amulet/level/java/chunk_/components/light_populated.py

@@ -1,12 +0,0 @@
-# from __future__ import annotations
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class LightPopulatedComponent(ChunkComponent[bool, bool]):
-#     storage_key = b"jtp"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: bool, new_obj: bool) -> bool:
-#         if not isinstance(new_obj, bool):
-#             raise TypeError
-#         return new_obj

amulet/level/java/chunk_/components/named_height_2d.py

@@ -1,37 +0,0 @@
-# import numpy
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class NamedHeight2DData:
-#     arrays: dict[str, numpy.ndarray]
-#
-#     def __init__(
-#         self, shape: tuple[int, int], arrays: dict[str, numpy.ndarray]
-#     ) -> None:
-#         self._shape = shape
-#         self.arrays = arrays
-#
-#     @property
-#     def shape(self) -> tuple[int, int]:
-#         return self._shape
-#
-#
-# class NamedHeight2DComponent(ChunkComponent[NamedHeight2DData, NamedHeight2DData]):
-#     storage_key = b"nh2d"
-#
-#     @staticmethod
-#     def fix_set_data(
-#         old_obj: NamedHeight2DData, new_obj: NamedHeight2DData
-#     ) -> NamedHeight2DData:
-#         if not isinstance(new_obj, NamedHeight2DData):
-#             raise TypeError
-#         if new_obj.shape != old_obj.shape:
-#             raise ValueError
-#         for key, value in new_obj.arrays.items():
-#             if not isinstance(key, str):
-#                 raise TypeError
-#             if not isinstance(value, numpy.ndarray):
-#                 raise TypeError
-#             if value.shape != old_obj.shape:
-#                 raise ValueError
-#         return new_obj

amulet/level/java/chunk_/components/status.py

@@ -1,11 +0,0 @@
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class StatusComponent(ChunkComponent[str, str]):
-#     storage_key = b"jst"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: str, new_obj: str) -> str:
-#         if not isinstance(new_obj, str):
-#             raise TypeError
-#         return new_obj

amulet/level/java/chunk_/components/terrain_populated.py

@@ -1,12 +0,0 @@
-# from __future__ import annotations
-# from amulet.chunk.components.abc import ChunkComponent
-#
-#
-# class TerrainPopulatedComponent(ChunkComponent[bool, bool]):
-#     storage_key = b"jtp"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: bool, new_obj: bool) -> bool:
-#         if not isinstance(new_obj, bool):
-#             raise TypeError
-#         return new_obj