amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

amulet/chunk_/components/biome.py

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

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

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

@@ -0,0 +1,16 @@
+# 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/chunk_components.pyi

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.block
+import amulet.collections
+import amulet.palette.block_palette
+import amulet.version
+import numpy
+import typing_extensions
+
+__all__ = ["BlockComponent", "BlockComponentData", "IndexArray3D", "SectionArrayMap"]
+
+class BlockComponent:
+    ComponentID: typing.ClassVar[str] = "Amulet::BlockComponent"
+    block: BlockComponentData
+
+class BlockComponentData:
+    def __init__(
+        self,
+        version_range: amulet.version.VersionRange,
+        array_shape: tuple[int, int, int],
+        default_block: amulet.block.BlockStack,
+    ) -> None: ...
+    @property
+    def palette(self) -> amulet.palette.block_palette.BlockPalette: ...
+    @property
+    def sections(self) -> SectionArrayMap: ...
+
+class IndexArray3D:
+    """
+    A 3D index array.
+    """
+
+    def __buffer__(self, flags):
+        """
+        Return a buffer object that exposes the underlying memory of the object.
+        """
+
+    @typing.overload
+    def __init__(self, shape: tuple[int, int, int]) -> None: ...
+    @typing.overload
+    def __init__(self, shape: tuple[int, int, int], value: int) -> None: ...
+    @typing.overload
+    def __init__(self, other: IndexArray3D) -> None: ...
+    @typing.overload
+    def __init__(self, arg0: typing_extensions.Buffer) -> None: ...
+    def __release_buffer__(self, buffer):
+        """
+        Release the buffer object that exposes the underlying memory of the object.
+        """
+
+    @property
+    def shape(self) -> tuple[int, int, int]: ...
+    @property
+    def size(self) -> int: ...
+
+class SectionArrayMap:
+    """
+    A container of sub-chunk arrays.
+    """
+
+    def __contains__(self, arg0: int) -> bool: ...
+    def __delitem__(self, arg0: int) -> None: ...
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __getitem__(self, arg0: int) -> typing.Any: ...
+    def __hash__(self) -> int: ...
+    def __init__(
+        self,
+        array_shape: tuple[int, int, int],
+        default_array: int | IndexArray3D | typing_extensions.Buffer,
+    ) -> None: ...
+    def __iter__(self) -> amulet.collections.Iterator: ...
+    def __len__(self) -> int: ...
+    def __setitem__(
+        self, arg0: int, arg1: IndexArray3D | typing_extensions.Buffer
+    ) -> None: ...
+    def get(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def items(self) -> typing.Any: ...
+    def keys(self) -> typing.Any: ...
+    def pop(self, key: typing.Any, default: typing.Any = ...) -> typing.Any: ...
+    def popitem(self) -> tuple[typing.Any, typing.Any]: ...
+    def populate(self, arg0: int) -> None: ...
+    def setdefault(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def update(self, other: typing.Any = (), **kwargs) -> None: ...
+    def values(self) -> typing.Any: ...
+    @property
+    def array_shape(self) -> tuple[int, int, int]: ...
+    @property
+    def default_array(self) -> int | numpy.ndarray: ...
+    @default_array.setter
+    def default_array(
+        self, arg1: int | IndexArray3D | typing_extensions.Buffer
+    ) -> None: ...

amulet/collections.pyi

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import types
+import typing
+
+__all__ = ["Holder", "Iterator", "Mapping", "MutableMapping"]
+
+class Holder:
+    """
+    A utility class for keeping smart pointers alive.
+    """
+
+class Iterator:
+    def __iter__(self: typing.Iterator) -> typing.Iterator: ...
+    def __next__(self: typing.Iterator) -> typing.Any: ...
+
+class Mapping:
+    def __contains__(self, arg0: typing.Any) -> bool: ...
+    def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
+    def __getitem__(self, arg0: typing.Any) -> typing.Any: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> typing.Iterator: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def get(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def items(self) -> typing.Any: ...
+    def keys(self) -> typing.Any: ...
+    def values(self) -> typing.Any: ...
+
+class MutableMapping(Mapping):
+    def __delitem__(self, arg0: typing.Any) -> None: ...
+    def __setitem__(self, arg0: typing.Any, arg1: typing.Any) -> None: ...
+    def clear(self) -> None: ...
+    def pop(self, key: typing.Any, default: typing.Any = ...) -> typing.Any: ...
+    def popitem(self) -> tuple[typing.Any, typing.Any]: ...
+    def setdefault(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def update(self, other: typing.Any = (), **kwargs) -> None: ...

amulet/data_types.py

@@ -0,0 +1,29 @@
+from typing import TypeAlias
+import numpy
+
+#: The type for a dimension identifier
+DimensionId: TypeAlias = str
+
+#: The data type for the x and z coordinates of a region file. Note these are no the same as block coordinates.
+RegionCoordinates: TypeAlias = tuple[int, int]
+
+#: The data type for the x and z coordinate of a chunk. Note these are no the same as block coordinates.
+ChunkCoordinates: TypeAlias = tuple[int, int]
+
+#: The data type for the x, y and z coordinates of a sub-chunk within the world. Note these are no the same as block coordinates.
+SubChunkCoordinates: TypeAlias = tuple[int, int, int]
+
+#: The data type for the x, y and z location of a block within the world.
+BlockCoordinates: TypeAlias = tuple[int, int, int]
+
+#: The data type for the x, y and z location of a block within the world in the form of a numpy array.
+BlockCoordinatesArray: TypeAlias = numpy.ndarray  # NDArray[(3, ), int]
+
+#: The data type for the x, y and z location of a point within the world.
+PointCoordinates: TypeAlias = tuple[float, float, float]
+
+#: The data type for the x, y and z location of a point within the world in the form of a numpy array.
+PointCoordinatesArray: TypeAlias = numpy.ndarray  # NDArray[(3, ), numpy.float]
+
+#: The data type for a tuple containing three floats. Use :data:`PointCoordinates` for x, y, z float coordinates.
+FloatTriplet: TypeAlias = tuple[float, float, float]

amulet/entity.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from typing import Any
+from amulet_nbt import NamedTag
+from amulet.version import PlatformVersionContainer, VersionNumber
+from amulet.data_types import PointCoordinates
+
+
+class Entity(PlatformVersionContainer):
+    """
+    A class to contain all the data to define an Entity.
+    """
+
+    __slots__ = (
+        "_namespace",
+        "_base_name",
+        "_x",
+        "_y",
+        "_z",
+        "_nbt",
+    )
+
+    def __init__(
+        self,
+        platform: str,
+        version: VersionNumber,
+        namespace: str,
+        base_name: str,
+        x: float,
+        y: float,
+        z: float,
+        nbt: NamedTag,
+    ) -> None:
+        """
+        Constructs a :class:`Entity` instance.
+
+        :param platform: The platform the entity is defined in.
+        :param version: The version the entity is defined in.
+        :param namespace: The namespace of the entity eg "minecraft"
+        :param base_name: The base name of the entity eg "creeper"
+        :param x: The x coordinate of the entity
+        :param y: The y coordinate of the entity
+        :param z: The z coordinate of the entity
+        :param nbt: The NBT stored with the entity
+        """
+        super().__init__(platform, version)
+        self._namespace = str(namespace)
+        self._base_name = str(base_name)
+        self._x = float(x)
+        self._y = float(y)
+        self._z = float(z)
+        if not isinstance(nbt, NamedTag):
+            raise TypeError(f"nbt must be an NamedTag. Got {nbt}")
+        self._nbt = nbt
+
+    def __getstate__(self) -> tuple[tuple[str, VersionNumber], tuple[str, str, float, float, float, NamedTag]]:  # type: ignore[override]
+        return (
+            super().__getstate__(),
+            (
+                self._namespace,
+                self._base_name,
+                self._x,
+                self._y,
+                self._z,
+                self._nbt,
+            ),
+        )
+
+    def __setstate__(self, state: tuple[tuple[str, VersionNumber], tuple[str, str, float, float, float, NamedTag]]) -> None:  # type: ignore[override]
+        super().__setstate__(state[0])
+        (
+            self._namespace,
+            self._base_name,
+            self._x,
+            self._y,
+            self._z,
+            self._nbt,
+        ) = state[1]
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Entity):
+            return NotImplemented
+        return self.__getstate__() == other.__getstate__()
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    def __repr__(self) -> str:
+        return f"Entity({self.platform!r}, {self.version!r}, {self._namespace!r}, {self._base_name!r}, {self._x}, {self._y}, {self._z}, {self._nbt!r})"
+
+    @property
+    def namespaced_name(self) -> str:
+        """
+        The namespace:base_name of the entity represented by the object (eg: `minecraft:creeper`)
+
+        If the given namespace is an empty string it will just return the base name.
+
+        :return: namespace:base_name of the entity
+        """
+        return f"{self._namespace}:{self._base_name}"
+
+    @property
+    def namespace(self) -> str:
+        """
+        The namespace of the entity represented by the Entity object (eg: `minecraft`)
+
+        :return: The namespace of the entity
+        """
+        return self._namespace
+
+    @namespace.setter
+    def namespace(self, value: str) -> None:
+        self._namespace = value
+
+    @property
+    def base_name(self) -> str:
+        """
+        The base name of the entity represented by the Entity object (eg: `creeper`, `pig`)
+
+        :return: The base name of the entity
+        """
+        return self._base_name
+
+    @base_name.setter
+    def base_name(self, value: str) -> None:
+        self._base_name = value
+
+    @property
+    def x(self) -> float:
+        """The x location of the Entity."""
+        return self._x
+
+    @x.setter
+    def x(self, value: float) -> None:
+        self._x = float(value)
+
+    @property
+    def y(self) -> float:
+        """The y location of the Entity."""
+        return self._y
+
+    @y.setter
+    def y(self, value: float) -> None:
+        self._y = float(value)
+
+    @property
+    def z(self) -> float:
+        """The z location of the Entity."""
+        return self._z
+
+    @z.setter
+    def z(self, value: float) -> None:
+        self._z = float(value)
+
+    @property
+    def location(self) -> PointCoordinates:
+        """The location of the Entity."""
+        return self._x, self._y, self._z
+
+    @location.setter
+    def location(self, location: PointCoordinates) -> None:
+        self.x, self.y, self.z = location
+
+    @property
+    def nbt(self) -> NamedTag:
+        """
+        The NBT behind the object
+
+        :getter: Get the NBT data stored in the object
+        :setter: Set the NBT data stored in the object
+
+        :return: A NamedTag
+        """
+        return self._nbt
+
+    @nbt.setter
+    def nbt(self, value: NamedTag) -> None:
+        if not isinstance(value, NamedTag):
+            raise TypeError
+        self._nbt = value