amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

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

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

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

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

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

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

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

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

amulet/level/java/chunk_components.pyi

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet_nbt
+
+__all__ = ["DataVersionComponent", "JavaRawChunkComponent"]
+
+class DataVersionComponent:
+    ComponentID: typing.ClassVar[str] = "Amulet::DataVersionComponent"
+    @property
+    def data_version(self) -> int: ...
+
+class JavaRawChunkComponent:
+    ComponentID: typing.ClassVar[str] = "Amulet::JavaRawChunkComponent"
+    @property
+    def raw_data(self) -> collections.abc.MutableMapping[str, amulet_nbt.NamedTag]: ...
+    @raw_data.setter
+    def raw_data(
+        self, arg1: collections.abc.Mapping[str, amulet_nbt.NamedTag]
+    ) -> None: ...

amulet/level/java/long_array.pyi

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import numpy
+import typing_extensions
+
+__all__ = ["decode_long_array", "encode_long_array"]
+
+def decode_long_array(
+    long_array: typing_extensions.Buffer,
+    size: int,
+    bits_per_entry: int,
+    dense: bool = True,
+) -> numpy.ndarray:
+    """
+    Decode a long array (from BlockStates or Heightmaps)
+
+    :param long_array: Encoded long array
+    :param size: The expected size of the returned array
+    :param bits_per_entry: The number of bits per entry in the encoded array.
+    :param dense: If true the long arrays will be treated as a bit stream. If false they are distinct values with padding
+    :return: Decoded array as numpy array
+    """
+
+def encode_long_array(
+    array: typing_extensions.Buffer,
+    bits_per_entry: None | int = None,
+    dense: bool = True,
+    min_bits_per_entry: int = 1,
+) -> numpy.ndarray[numpy.uint64]:
+    """
+    Encode a long array (from BlockStates or Heightmaps)
+
+    :param array: A numpy array of the data to be encoded.
+    :param bits_per_entry: The number of bits to use to store each value. If left as None will use the smallest bits per entry.
+    :param dense: If true the long arrays will be treated as a bit stream. If false they are distinct values with padding
+    :param min_bits_per_entry: The mimimum value that bits_per_entry can be. If it is less than this it will be capped at this value.
+    :return: Encoded array as numpy array
+    """

amulet/level/temporary_level/__init__.py

@@ -0,0 +1 @@
+from ._level import TemporaryLevel

amulet/level/temporary_level/_level.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+from amulet.level.abc import Level, CreatableLevel
+from amulet.utils.call_spec import method_spec
+
+
+class TemporaryLevel(Level, CreatableLevel):
+    """A temporary level that exists only in memory."""
+
+    __slots__ = ()
+
+    @classmethod
+    @method_spec()
+    def create(cls, *args: Any, **kwargs: Any) -> TemporaryLevel:
+        raise NotImplementedError

amulet/palette/__init__.pyi

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from amulet.palette.biome_palette import BiomePalette
+from amulet.palette.block_palette import BlockPalette
+
+from . import biome_palette, block_palette
+
+__all__ = ["BiomePalette", "BlockPalette", "biome_palette", "block_palette"]

amulet/palette/biome_palette.pyi

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet.biome
+import amulet.version
+
+__all__ = ["BiomePalette"]
+
+class BiomePalette(amulet.version.VersionRangeContainer):
+    @typing.overload
+    def __contains__(self, arg0: int) -> bool: ...
+    @typing.overload
+    def __contains__(self, arg0: amulet.biome.Biome) -> bool: ...
+    @typing.overload
+    def __getitem__(self, arg0: int) -> amulet.biome.Biome: ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> list: ...
+    def __init__(self, arg0: amulet.version.VersionRange) -> None: ...
+    def __iter__(self) -> collections.abc.Iterator[typing.Any]: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(self) -> collections.abc.Iterator[typing.Any]: ...
+    def biome_to_index(self, arg0: amulet.biome.Biome) -> int:
+        """
+        Get the index of the biome in the palette.
+        If it is not in the palette already it will be added first.
+
+        :param biome: The biome to get the index of.
+        :return: The index of the biome in the palette.
+        """
+
+    def count(self, value: typing.Any) -> int: ...
+    def index(
+        self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
+    ) -> int: ...
+    def index_to_biome(self, arg0: int) -> amulet.biome.Biome:
+        """
+        Get the biome at the specified palette index.
+
+        :param index: The index to get
+        :return: The biome at that index
+        :raises IndexError if there is no biome at that index.
+        """

amulet/palette/block_palette.pyi

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import amulet.block
+import amulet.version
+
+__all__ = ["BlockPalette"]
+
+class BlockPalette(amulet.version.VersionRangeContainer):
+    @typing.overload
+    def __contains__(self, arg0: int) -> bool: ...
+    @typing.overload
+    def __contains__(self, arg0: amulet.block.BlockStack) -> bool: ...
+    @typing.overload
+    def __getitem__(self, arg0: int) -> amulet.block.BlockStack: ...
+    @typing.overload
+    def __getitem__(self, arg0: slice) -> list: ...
+    def __init__(self, arg0: amulet.version.VersionRange) -> None: ...
+    def __iter__(self) -> collections.abc.Iterator[typing.Any]: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(self) -> collections.abc.Iterator[typing.Any]: ...
+    def block_stack_to_index(self, arg0: amulet.block.BlockStack) -> int:
+        """
+        Get the index of the block stack in the palette.
+        If it is not in the palette already it will be added first.
+
+        :param block_stack: The block stack to get the index of.
+        :return: The index of the block stack in the palette.
+        """
+
+    def count(self, value: typing.Any) -> int: ...
+    def index(
+        self, value: typing.Any, start: int = 0, stop: int = 9223372036854775807
+    ) -> int: ...
+    def index_to_block_stack(self, arg0: int) -> amulet.block.BlockStack:
+        """
+        Get the block stack at the specified palette index.
+
+        :param index: The index to get
+        :return: The block stack at that index
+        :raises IndexError if there is no block stack at that index.
+        """

amulet/player.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from amulet.data_types import DimensionId
+
+LOCAL_PLAYER = "~local_player"
+
+
+class Player:
+    def __init__(
+        self,
+        player_id: str,
+        dimension_id: DimensionId,
+        location: Tuple[float, float, float],
+        rotation: Tuple[float, float],
+    ) -> None:
+        """
+        Creates a new instance of :class:`Player` with the given UUID, location, and rotation
+
+        :param player_id: The ID of the player
+        :param location: The location of the player in world coordinates
+        :param rotation: The rotation of the player
+        :param dimension_id: The dimension the player is in
+        """
+        super().__init__()
+        assert isinstance(player_id, str)
+        assert (
+            isinstance(location, tuple)
+            and len(location) == 3
+            and all(isinstance(f, float) for f in location)
+        )
+        assert (
+            isinstance(rotation, tuple)
+            and len(rotation) == 2
+            and all(isinstance(f, float) for f in rotation)
+        )
+        self._player_id = player_id
+        self._location = location
+        self._rotation = rotation
+        self._dimension_id = dimension_id
+
+    def __repr__(self) -> str:
+        return f"Player({self.player_id}, {self.dimension_id}, {self.location}, {self.rotation})"
+
+    @property
+    def player_id(self) -> str:
+        """The player's ID"""
+        return self._player_id
+
+    @property
+    def location(self) -> Tuple[float, float, float]:
+        """The current location of the player in the world"""
+        return self._location
+
+    @property
+    def rotation(self) -> Tuple[float, float]:
+        """The current rotation of the player in the world"""
+        return self._rotation
+
+    @property
+    def dimension_id(self) -> DimensionId:
+        """The current dimension the player is in"""
+        return self._dimension_id

amulet/selection/__init__.py

@@ -0,0 +1,2 @@
+from .group import SelectionGroup
+from .box import SelectionBox