amulet-core 2.0a6__cp311-cp311-win_amd64.whl → 2.0a7__cp311-cp311-win_amd64.whl

amulet/chunk_/components/biome.py

@@ -1,155 +0,0 @@
-# from __future__ import annotations
-#
-# from typing import Union, Iterable
-# from collections.abc import Mapping
-#
-# import numpy
-# from numpy.typing import ArrayLike
-#
-# from amulet.version import VersionRange
-# from amulet.biome import Biome
-# from amulet.palette import BiomePalette
-# from amulet.chunk.components.sub_chunk_array import SubChunkArrayContainer
-# from amulet.utils.typed_property import TypedProperty
-#
-# from .abc import ChunkComponent
-#
-#
-# class Biome2DComponentData:
-#     _array: numpy.ndarray
-#
-#     def __init__(
-#         self,
-#         version_range: VersionRange,
-#         array_shape: tuple[int, int],
-#         default_biome: Biome,
-#     ):
-#         if (
-#             not isinstance(array_shape, tuple)
-#             and len(array_shape) == 2
-#             and all(isinstance(s, int) for s in array_shape)
-#         ):
-#             raise TypeError
-#
-#         self._array_shape = array_shape
-#         self._palette = BiomePalette(version_range)
-#         self._palette.biome_to_index(default_biome)
-#         self._set_biome(0)
-#
-#     def __getstate__(self) -> tuple[tuple[int, int], BiomePalette, numpy.ndarray]:
-#         return self._array_shape, self._palette, self._array
-#
-#     def __setstate__(
-#         self, state: tuple[tuple[int, int], BiomePalette, numpy.ndarray]
-#     ) -> None:
-#         self._array_shape, self._palette, self._array = state
-#
-#     @property
-#     def array_shape(self) -> tuple[int, int]:
-#         return self._array_shape
-#
-#     @TypedProperty[numpy.ndarray, Union[int, ArrayLike]]
-#     def array(self) -> numpy.ndarray:
-#         return self._array
-#
-#     @array.setter
-#     def _set_biome(
-#         self,
-#         array: Union[int, ArrayLike],
-#     ) -> None:
-#         if isinstance(array, int):
-#             self._array = numpy.full(self._array_shape, array, dtype=numpy.uint32)
-#         else:
-#             array = numpy.asarray(array)
-#             if not isinstance(array, numpy.ndarray):
-#                 raise TypeError
-#             if array.shape != self._array_shape or array.dtype != numpy.uint32:
-#                 raise ValueError
-#             self._array = numpy.array(array)
-#
-#     @property
-#     def palette(self) -> BiomePalette:
-#         return self._palette
-#
-#
-# class Biome2DComponent(ChunkComponent[Biome2DComponentData, Biome2DComponentData]):
-#     storage_key = b"b2d"
-#
-#     @staticmethod
-#     def fix_set_data(
-#         old_obj: Biome2DComponentData, new_obj: Biome2DComponentData
-#     ) -> Biome2DComponentData:
-#         if not isinstance(new_obj, Biome2DComponentData):
-#             raise TypeError
-#         assert isinstance(old_obj, Biome2DComponentData)
-#         if (
-#             old_obj.array.shape != new_obj.array.shape
-#             or old_obj.array_shape != new_obj.array_shape
-#         ):
-#             raise ValueError("New array shape does not match old array shape.")
-#         elif old_obj.palette.version_range != new_obj.palette.version_range:
-#             raise ValueError("New version range does not match old version range.")
-#         return new_obj
-#
-#
-# class Biome3DComponentData:
-#     def __init__(
-#         self,
-#         version_range: VersionRange,
-#         array_shape: tuple[int, int, int],
-#         default_biome: Biome,
-#     ):
-#         self._palette = BiomePalette(version_range)
-#         self._palette.biome_to_index(default_biome)
-#         self._sections = SubChunkArrayContainer(array_shape, 0)
-#
-#     def __getstate__(self) -> tuple[BiomePalette, SubChunkArrayContainer]:
-#         return self._palette, self._sections
-#
-#     def __setstate__(self, state: tuple[BiomePalette, SubChunkArrayContainer]) -> None:
-#         self._palette, self._sections = state
-#
-#     @TypedProperty[
-#         SubChunkArrayContainer,
-#         SubChunkArrayContainer
-#         | Mapping[int, numpy.ndarray]
-#         | Iterable[tuple[int, numpy.ndarray]],
-#     ]
-#     def sections(self) -> SubChunkArrayContainer:
-#         return self._sections
-#
-#     @sections.setter
-#     def _set_biome(
-#         self,
-#         sections: (
-#             SubChunkArrayContainer
-#             | Mapping[int, numpy.ndarray]
-#             | Iterable[tuple[int, numpy.ndarray]]
-#         ),
-#     ) -> None:
-#         if sections is not self._sections:
-#             self._sections.clear()
-#             self._sections.update(sections)
-#             if isinstance(sections, SubChunkArrayContainer):
-#                 self._sections.default_array = sections.default_array
-#
-#     @property
-#     def palette(self) -> BiomePalette:
-#         return self._palette
-#
-#
-# class Biome3DComponent(ChunkComponent[Biome3DComponentData, Biome3DComponentData]):
-#     storage_key = b"b3d"
-#
-#     @staticmethod
-#     def fix_set_data(
-#         old_obj: Biome3DComponentData, new_obj: Biome3DComponentData
-#     ) -> Biome3DComponentData:
-#         if not isinstance(new_obj, Biome3DComponentData):
-#             raise TypeError
-#         assert isinstance(old_obj, Biome3DComponentData)
-#         if old_obj.sections.array_shape != new_obj.sections.array_shape:
-#             raise ValueError("New array shape does not match old array shape.")
-#         elif old_obj.palette.version_range != new_obj.palette.version_range:
-#             raise ValueError("New version range does not match old version range.")
-#         return new_obj

amulet/chunk_/components/block_entity.py

@@ -1,117 +0,0 @@
-# from __future__ import annotations
-#
-# from collections.abc import MutableMapping
-# from typing import Iterator, Any
-#
-# from amulet.data_types import BlockCoordinates
-# from amulet.block_entity import BlockEntity
-# from amulet.version import VersionRange, VersionRangeContainer
-#
-# from .abc import ChunkComponent, UnloadedComponent
-#
-#
-# class BlockEntityComponentData(
-#     VersionRangeContainer, MutableMapping[BlockCoordinates, BlockEntity]
-# ):
-#     """
-#     A MutableMapping that can only store :class:`BlockEntity` instances
-#     under the absolute coordinate of the block entity ``Tuple[int, int, int]``
-#     """
-#
-#     _block_entities: dict[BlockCoordinates, BlockEntity]
-#
-#     def __init__(
-#         self,
-#         version_range: VersionRange,
-#     ) -> None:
-#         super().__init__(version_range)
-#         self._block_entities = {}
-#
-#     def __getstate__(self) -> tuple[VersionRange, dict[BlockCoordinates, BlockEntity]]:  # type: ignore[override]
-#         return (
-#             super().__getstate__(),
-#             self._block_entities,
-#         )
-#
-#     def __setstate__(self, state: tuple[VersionRange, dict[BlockCoordinates, BlockEntity]]) -> None:  # type: ignore[override]
-#         super().__setstate__(state[0])
-#         self._block_entities = state[1]
-#
-#     def __setitem__(
-#         self, coordinate: BlockCoordinates, block_entity: BlockEntity
-#     ) -> None:
-#         """
-#         Set the :class:`BlockEntity` at ``coordinate``.
-#
-#         >>> block_entities: BlockEntityComponentData
-#         >>> x = y = z = 0
-#         >>> block_entities[(x, y, z)] = block_entity
-#
-#         :param coordinate: The coordinate to set the block entity at.
-#         :param block_entity: The block entity to set at the specified coordinate.
-#         """
-#         if (
-#             not isinstance(coordinate, tuple)
-#             and len(coordinate) == 3
-#             and all(isinstance(c, int) for c in coordinate)
-#         ):
-#             raise TypeError
-#         if not isinstance(block_entity, BlockEntity):
-#             raise TypeError
-#         if not self.version_range.contains(block_entity.platform, block_entity.version):
-#             raise ValueError(
-#                 f"block entity {block_entity} is incompatible with {self.version_range}"
-#             )
-#         self._block_entities[coordinate] = block_entity
-#
-#     def __delitem__(self, coordinate: BlockCoordinates) -> None:
-#         """
-#         Remove the :class:`BlockEntity` at ``coordinate``.
-#
-#         :param coordinate: The coordinate to remove the block entity from.
-#         """
-#         del self._block_entities[coordinate]
-#
-#     def __getitem__(self, coordinate: BlockCoordinates) -> BlockEntity:
-#         """
-#         Get the :class:`BlockEntity` at ``coordinate``.
-#
-#         >>> block_entities: BlockEntityComponentData
-#         >>> x = y = z = 0
-#         >>> block_entity = block_entities[(x, y, z)]
-#
-#         :param coordinate: The coordinate to find the block entity at.
-#         :return: The block entity at the specified coordinate.
-#         :raises:
-#             KeyError if there is no BlockEntity at the given coordinate.
-#         """
-#         return self._block_entities[coordinate]
-#
-#     def __len__(self) -> int:
-#         return len(self._block_entities)
-#
-#     def __iter__(self) -> Iterator[BlockCoordinates]:
-#         yield from self._block_entities
-#
-#     def __repr__(self) -> str:
-#         return (
-#             f"BlockEntityContainer({self.version_range!r}) # {len(self)} block entities"
-#         )
-#
-#
-# class BlockEntityComponent(
-#     ChunkComponent[BlockEntityComponentData, BlockEntityComponentData]
-# ):
-#     storage_key = b"be"
-#
-#     @staticmethod
-#     def fix_set_data(
-#         old_obj: BlockEntityComponentData | UnloadedComponent,
-#         new_obj: BlockEntityComponentData,
-#     ) -> BlockEntityComponentData:
-#         if not isinstance(new_obj, BlockEntityComponentData):
-#             raise TypeError
-#         assert isinstance(old_obj, BlockEntityComponentData)
-#         if old_obj.version_range != new_obj.version_range:
-#             raise ValueError("New version range does not match old version range.")
-#         return new_obj

amulet/chunk_/components/entity.py

@@ -1,64 +0,0 @@
-# from __future__ import annotations
-# from typing import Iterator, Any
-# from collections.abc import MutableSet
-#
-# from amulet.entity import Entity
-# from amulet.version import VersionRange, VersionRangeContainer
-# from .abc import ChunkComponent
-#
-#
-# class EntityComponentData(VersionRangeContainer, MutableSet[Entity]):
-#     _entities: set[Entity]
-#
-#     def __init__(self, version_range: VersionRange):
-#         super().__init__(version_range)
-#         self._entities = set()
-#
-#     def __getstate__(self) -> tuple[VersionRange, set[Entity]]:  # type: ignore[override]
-#         return (
-#             super().__getstate__(),
-#             self._entities,
-#         )
-#
-#     def __setstate__(self, state: tuple[VersionRange, set[Entity]]) -> None:  # type: ignore[override]
-#         super().__setstate__(state[0])
-#         self._entities = state[1]
-#
-#     def add(self, entity: Entity) -> None:
-#         if not isinstance(entity, Entity):
-#             raise TypeError("Expected an Entity")
-#         if not self.version_range.contains(entity.platform, entity.version):
-#             raise ValueError(
-#                 f"entity {entity} is incompatible with {self.version_range}"
-#             )
-#         self._entities.add(entity)
-#
-#     def discard(self, entity: Entity) -> None:
-#         self._entities.discard(entity)
-#
-#     def __contains__(self, entity: object) -> bool:
-#         return entity in self._entities
-#
-#     def __len__(self) -> int:
-#         return len(self._entities)
-#
-#     def __iter__(self) -> Iterator[Entity]:
-#         yield from self._entities
-#
-#     def __repr__(self) -> str:
-#         return f"EntityContainer({self.version_range!r}) # {len(self)} entities"
-#
-#
-# class EntityComponent(ChunkComponent[EntityComponentData, EntityComponentData]):
-#     storage_key = b"e"
-#
-#     @staticmethod
-#     def fix_set_data(
-#         old_obj: EntityComponentData, new_obj: EntityComponentData
-#     ) -> EntityComponentData:
-#         if not isinstance(new_obj, EntityComponentData):
-#             raise TypeError
-#         assert isinstance(old_obj, EntityComponentData)
-#         if old_obj.version_range != new_obj.version_range:
-#             raise ValueError("New version range does not match old version range.")
-#         return new_obj

amulet/chunk_/components/height_2d.py

@@ -1,16 +0,0 @@
-# import numpy
-# from numpy.typing import ArrayLike
-# from .abc import ChunkComponent
-#
-#
-# class Height2DComponent(ChunkComponent[numpy.ndarray, ArrayLike]):
-#     storage_key = b"h2d"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: numpy.ndarray, new_obj: ArrayLike) -> numpy.ndarray:
-#         new_obj = numpy.asarray(new_obj, numpy.int64)
-#         if not isinstance(new_obj, numpy.ndarray):
-#             raise TypeError
-#         if new_obj.shape != old_obj.shape or new_obj.dtype != numpy.int64:
-#             raise ValueError
-#         return new_obj

amulet/level/bedrock/__init__.py

@@ -1,2 +0,0 @@
-from ._level import BedrockLevel
-from ._raw import BedrockLevelDAT, BedrockCreateArgsV1

amulet/level/bedrock/_chunk_handle.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from amulet.level.abc import ChunkHandle
-from ..abc._chunk_handle import ChunkT
-from .chunk import BedrockChunk
-
-if TYPE_CHECKING:
-    from ._level import BedrockLevel
-    from ._raw import BedrockRawDimension
-
-
-class BedrockChunkHandle(
-    ChunkHandle["BedrockLevel", "BedrockRawDimension", BedrockChunk]
-):
-    @staticmethod
-    def _validate_chunk(chunk: ChunkT) -> None:
-        if not isinstance(chunk, BedrockChunk):
-            raise TypeError

amulet/level/bedrock/_dimension.py

@@ -1,22 +0,0 @@
-from typing import TYPE_CHECKING
-
-from amulet.level.abc import Dimension
-from ._chunk_handle import BedrockChunkHandle
-
-if TYPE_CHECKING:
-    from ._level import BedrockLevel
-    from ._raw import BedrockRawDimension
-
-
-class BedrockDimension(
-    Dimension["BedrockLevel", "BedrockRawDimension", BedrockChunkHandle]
-):
-    def _create_chunk_handle(self, cx: int, cz: int) -> BedrockChunkHandle:
-        return BedrockChunkHandle(
-            self._l_ref,
-            self._chunk_history,
-            self._chunk_data_history,
-            self.dimension_id,
-            cx,
-            cz,
-        )

amulet/level/bedrock/_level.py

@@ -1,187 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Union, Type, Callable
-import os
-
-from PIL import Image
-
-from amulet.version import VersionNumber, PlatformType
-from amulet.data_types import DimensionId
-from amulet.level import register_level_class
-from amulet.level.abc import (
-    LevelOpenData,
-    DiskLevel,
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-    PlayerStorage,
-)
-from amulet.utils.format_utils import check_all_exist
-from amulet.utils.call_spec import (
-    StringArg,
-    IntArg,
-    CallableArg,
-    BoolArg,
-    DirectoryPathArg,
-    PositionalArgs,
-    method_spec,
-)
-from amulet.utils.weakref import DetachableWeakRef
-
-from ._raw import BedrockRawLevel, InternalDimension, BedrockCreateArgsV1
-from ._dimension import BedrockDimension
-from ...chunk import Chunk
-
-
-class BedrockLevelOpenData(LevelOpenData):
-    back_reference: Callable[[], BedrockLevel | None]
-    detach_back_reference: Callable[[], None]
-    dimensions: dict[Union[DimensionId, InternalDimension], BedrockDimension]
-
-    def __init__(self, level: BedrockLevel) -> None:
-        super().__init__()
-        self.back_reference, self.detach_back_reference = DetachableWeakRef.new(level)
-        self.dimensions = {}
-
-
-class BedrockLevel(
-    DiskLevel[BedrockLevelOpenData, BedrockDimension, BedrockRawLevel],
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-):
-    def save(self) -> None:
-        pass
-
-    @property
-    def native_chunk_class(self) -> Type[Chunk]:
-        raise NotImplementedError
-
-    _raw_level: BedrockRawLevel
-
-    __slots__ = ("_raw_level",)
-
-    def __init__(self, _ikwiad: bool = False) -> None:
-        if not _ikwiad:
-            raise RuntimeError(
-                "BedrockLevel cannot be directly initialised. Use create or load classmethod."
-            )
-        super().__init__()
-
-    def __init(self, raw: BedrockRawLevel) -> None:
-        self._raw_level = raw
-        self._raw_level.opened.connect(self.open)
-        self._raw_level.closed.connect(self.close)
-
-    @classmethod
-    @method_spec(
-        CallableArg(
-            BedrockCreateArgsV1,
-            BoolArg(True),
-            DirectoryPathArg(),
-            CallableArg(
-                VersionNumber,
-                PositionalArgs(IntArg(min_value=0), (IntArg(1), IntArg(20))),
-            ),
-            StringArg("New World"),
-        )
-    )
-    def create(cls, args: BedrockCreateArgsV1) -> BedrockLevel:
-        raw = BedrockRawLevel.create(args)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    @staticmethod
-    def can_load(token: Any) -> bool:
-        return (
-            isinstance(token, str)
-            and os.path.isdir(token)
-            and check_all_exist(token, "db", "level.dat", "levelname.txt")
-        )
-
-    @classmethod
-    def load(cls, path: str) -> BedrockLevel:
-        """Create a new instance from the level at the given directory."""
-        raw = BedrockRawLevel.load(path)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    def reload(self) -> None:
-        """
-        Reload the level metadata inplace.
-        The level must be closed when this is called.
-        """
-        self.raw.reload()
-
-    def _open(self) -> None:
-        self.raw.open()
-        self._open_data = BedrockLevelOpenData(self)
-
-    def _close(self) -> None:
-        self._o.detach_back_reference()
-        self._open_data = None
-        self.raw.close()
-
-    @property
-    def path(self) -> str:
-        return self.raw.path
-
-    @property
-    def level_name(self) -> str:
-        try:
-            level_name_tag = self.raw.level_dat.compound.get_string("LevelName")
-            assert level_name_tag is not None
-            return level_name_tag.py_str
-        except Exception:
-            return "Unknown level name"
-
-    @property
-    def modified_time(self) -> float:
-        return self.raw.modified_time
-
-    @property
-    def thumbnail(self) -> Image.Image:
-        try:
-            return Image.open(os.path.join(self.path, "world_icon.jpeg"))
-        except Exception:
-            return super().thumbnail
-
-    @property
-    def platform(self) -> PlatformType:
-        return "bedrock"
-
-    @property
-    def max_game_version(self) -> VersionNumber:
-        return self.raw.version
-
-    def dimension_ids(self) -> frozenset[DimensionId]:
-        return self.raw.dimension_ids()
-
-    def get_dimension(
-        self, dimension_id: Union[DimensionId, InternalDimension]
-    ) -> BedrockDimension:
-        dimensions = self._o.dimensions
-        if dimension_id not in dimensions:
-            raw_dimension = self.raw.get_dimension(dimension_id)
-            public_dimension_id = raw_dimension.dimension_id
-            internal_dimension_id = raw_dimension.internal_dimension_id
-            dimensions[internal_dimension_id] = dimensions[public_dimension_id] = (
-                BedrockDimension(self._o.back_reference, public_dimension_id)
-            )
-        return dimensions[dimension_id]
-
-    @property
-    def raw(self) -> BedrockRawLevel:
-        return self._raw_level
-
-    @property
-    def player(self) -> PlayerStorage:
-        raise NotImplementedError
-
-    def compact(self) -> None:
-        self.raw.level_db.compact()
-
-
-register_level_class(BedrockLevel)

amulet/level/bedrock/_raw/__init__.py

@@ -1,5 +0,0 @@
-from ._chunk import BedrockRawChunk
-from ._dimension import BedrockRawDimension
-from ._level import BedrockRawLevel, BedrockCreateArgsV1
-from ._level_dat import BedrockLevelDAT
-from ._typing import InternalDimension

amulet/level/bedrock/_raw/_actor_counter.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from threading import RLock
-
-from amulet_nbt import LongTag
-
-if TYPE_CHECKING:
-    from ._level import BedrockRawLevel
-
-
-class ActorCounter:
-    _lock: RLock
-    _session: int
-    _count: int
-
-    def __init__(self) -> None:
-        self._lock = RLock()
-        self._session = -1
-        self._count = 0
-
-    def init(self, raw: BedrockRawLevel) -> None:
-        """Initialise the session from the level.dat file.
-        This must be run after the level has been opened so that the level.dat can be written.
-        """
-        level_dat = raw.level_dat
-        session = level_dat.compound.get_long(
-            "worldStartCount", LongTag(0xFFFFFFFF)
-        ).py_int
-        # for some reason this is a signed int stored in a signed long. Manually apply the sign correctly
-        session -= (session & 0x80000000) << 1
-
-        # create the counter object and set the session
-        self._session = session
-
-        # increment and write back so there are no conflicts
-        session -= 1
-        if session < 0:
-            session += 0x100000000
-        level_dat.compound["worldStartCount"] = LongTag(session)
-        raw.level_dat = level_dat
-
-    def next(self) -> tuple[int, int]:
-        """
-        Get the next unique session id and actor counter.
-        Session id is usually negative
-
-        :return: Tuple[session id, actor id]
-        """
-        with self._lock:
-            count = self._count
-            self._count += 1
-        return self._session, count