amulet-core 1.9.19__py3-none-any.whl → 1.9.20__py3-none-any.whl

amulet/api/chunk/entity_list.py

@@ -1,75 +1,75 @@
-from collections import UserList
-from typing import Iterable
-from amulet.api.entity import Entity
-
-
-class ChunkList(UserList):
-    def __init__(self, iterable: Iterable = ()):
-        super().__init__(list(iterable))
-
-    def _check_all_types(self, value):
-        for val in value:
-            self._check_type(val)
-
-    def _check_type(self, value):
-        raise NotImplementedError
-
-    def append(self, value) -> None:
-        """Append value to the end of the list."""
-        self._check_type(value)
-        super().append(value)
-
-    def copy(self) -> "ChunkList":
-        raise NotImplementedError
-
-    def extend(self, iterable: Iterable):
-        """Extend list by appending elements from the iterable."""
-        self._check_all_types(iterable)
-        super().extend(iterable)
-
-    def insert(self, index: int, value):
-        """Insert value before index."""
-        self._check_type(value)
-        super().insert(index, value)
-
-    def __repr__(self):
-        if not self:
-            return "[]"
-        return "[" + "".join(f"\n\t{str(obj)}" for obj in self) + "\n]"
-
-
-class EntityList(ChunkList):
-    """
-    A custom implementation of the list class.
-
-    It can only store :class:`Entity` instances.
-    """
-
-    def __init__(self, entities: Iterable[Entity] = ()):
-        """
-        Construct an :class:`EntityList`.
-
-        :param entities: An Iterable of :class:`Entity` objects.
-        """
-        for e in entities:
-            self._check_type(e)
-        super().__init__(entities)
-
-    def _check_type(self, value):
-        assert isinstance(value, Entity), f"{value} is not an instance of Entity"
-
-    def copy(self) -> "EntityList":
-        """
-        Create a shallow copy of the entity container.
-        """
-        return EntityList(self)
-
-    def __iter__(self) -> Iterable[Entity]:
-        """
-        An iterable of all the :class:`Entity` objects.
-        """
-        yield from self.data
-
-    def __repr__(self) -> str:
-        """Return repr(self)."""
-        return f"EntityList({super().__repr__()})"
+from collections import UserList
+from typing import Iterable
+from amulet.api.entity import Entity
+
+
+class ChunkList(UserList):
+    def __init__(self, iterable: Iterable = ()):
+        super().__init__(list(iterable))
+
+    def _check_all_types(self, value):
+        for val in value:
+            self._check_type(val)
+
+    def _check_type(self, value):
+        raise NotImplementedError
+
+    def append(self, value) -> None:
+        """Append value to the end of the list."""
+        self._check_type(value)
+        super().append(value)
+
+    def copy(self) -> "ChunkList":
+        raise NotImplementedError
+
+    def extend(self, iterable: Iterable):
+        """Extend list by appending elements from the iterable."""
+        self._check_all_types(iterable)
+        super().extend(iterable)
+
+    def insert(self, index: int, value):
+        """Insert value before index."""
+        self._check_type(value)
+        super().insert(index, value)
+
+    def __repr__(self):
+        if not self:
+            return "[]"
+        return "[" + "".join(f"\n\t{str(obj)}" for obj in self) + "\n]"
+
+
+class EntityList(ChunkList):
+    """
+    A custom implementation of the list class.
+
+    It can only store :class:`Entity` instances.
+    """
+
+    def __init__(self, entities: Iterable[Entity] = ()):
+        """
+        Construct an :class:`EntityList`.
+
+        :param entities: An Iterable of :class:`Entity` objects.
+        """
+        for e in entities:
+            self._check_type(e)
+        super().__init__(entities)
+
+    def _check_type(self, value):
+        assert isinstance(value, Entity), f"{value} is not an instance of Entity"
+
+    def copy(self) -> "EntityList":
+        """
+        Create a shallow copy of the entity container.
+        """
+        return EntityList(self)
+
+    def __iter__(self) -> Iterable[Entity]:
+        """
+        An iterable of all the :class:`Entity` objects.
+        """
+        yield from self.data
+
+    def __repr__(self) -> str:
+        """Return repr(self)."""
+        return f"EntityList({super().__repr__()})"

amulet/api/chunk/status.py

@@ -1,167 +1,167 @@
-from typing import Union, Dict, List, Tuple
-from enum import Enum
-import logging
-
-log = logging.getLogger(__name__)
-
-
-class StatusFormats(Enum):
-    """
-    The different formats the status value can be converted to.
-
-    >>> StatusFormats.Raw  # The raw float value
-    >>> StatusFormats.Bedrock  # as an integer between 0 and 2
-    >>> StatusFormats.Java_13  # as a string
-    >>> StatusFormats.Java_14  # as a string
-    """
-
-    Raw = 0  # The raw float value
-    Bedrock = 1  # as an integer between 0 and 2
-    Java_13 = 2  # as a string
-    Java_14 = 3  # as a string
-    Java_20 = 20  # as a string
-
-
-J13 = StatusFormats.Java_13
-J14 = StatusFormats.Java_14
-J20 = StatusFormats.Java_20
-
-states = {
-    "empty": [[J13, J14], -1],
-    "minecraft:empty": [[J20], -1],
-    "structure_starts": [[J14], -0.9],
-    "minecraft:structure_starts": [[J20], -0.9],
-    "structure_references": [[J14], -0.8],
-    "minecraft:structure_references": [[J20], -0.8],
-    "biomes": [[J14], -0.7],
-    "minecraft:biomes": [[J20], -0.7],
-    "noise": [[J14], -0.6],
-    "minecraft:noise": [[J20], -0.6],
-    "base": [[J13], -0.5],
-    "surface": [[J14], -0.5],
-    "minecraft:surface": [[J20], -0.5],
-    "carved": [[J13], -0.4],
-    "carvers": [[J14], -0.4],
-    "minecraft:carvers": [[J20], -0.4],
-    "liquid_carved": [[J13], -0.3],
-    "liquid_carvers": [[J14], -0.3],
-    "decorated": [[J13], -0.2],
-    "features": [[J14], -0.2],
-    "minecraft:features": [[J20], -0.2],
-    "lighted": [[J13], -0.1],
-    "minecraft:initialize_light": [[J20], -0.1],
-    "light": [[J14], -0.1],
-    "minecraft:light": [[J20], -0.1],
-    # 0.0	needs ticked
-    # 1.0	needs population
-    "mobs_spawned": [[J13], 1.1],
-    "spawn": [[J14], 1.1],
-    "minecraft:spawn": [[J20], 1.1],
-    "finalized": [[J13], 1.5],
-    "heightmaps": [[J14], 1.5],
-    "fullchunk": [[J13], 1.9],
-    "postprocessed": [[J13], 2.0],
-    "full": [[J14], 2.0],
-    "minecraft:full": [[J20], 2.0],
-    # 2.0	done
-}
-
-versions: Dict[StatusFormats, List[Tuple[float, str]]] = {}
-for key, val in states.items():
-    for version_ in val[0]:
-        versions.setdefault(version_, []).append((val[1], key))
-for data in versions.values():
-    data.sort(key=lambda val_: val_[0], reverse=True)
-
-
-class Status:
-    """
-    A class to represent the generation state of a chunk.
-
-    This stores the chunk status as a float in the range -1 to 2 where -1 is nothing generated and 2 being fully generated.
-    """
-
-    def __init__(self):
-        """
-        Construct an instance of the :class:`Status` class.
-        """
-        self._value = 2.0
-
-    @property
-    def value(self) -> float:
-        """
-        **Getter**
-
-        Get the raw status value.
-
-        >>> status = chunk.status.value
-
-        :return: The float status value in the range -1 to 2
-
-        **Setter**
-
-        Set the status value.
-
-        >>> chunk.status.value = 2
-        >>> chunk.status.value = "full"
-
-        This can be a float/int or a string. If it is a string it is looked up in the states look up table to find the float value it corresponds with.
-
-        :param value: The value to set as the generation stage.
-        """
-        return self._value
-
-    @value.setter
-    def value(self, value: Union[float, int, str]):
-        """
-        Set the status value.
-
-        >>> chunk.status.value = 2
-        >>> chunk.status.value = "full"
-
-        This can be a float/int or a string. If it is a string it is looked up in the states look up table to find the float value it corresponds with.
-
-        :param value: The value to set as the generation stage.
-        """
-        if isinstance(value, float):
-            self._value = value
-        elif isinstance(value, int):
-            self._value = float(value)
-        elif isinstance(value, str) and value in states:
-            self._value = states[value][1]
-        else:
-            log.error(
-                f"Unrecognised chunk state {value}. Defaulting to fully generated.\nIf this is a new version report it to the developers."
-            )
-            self._value = 2.0
-
-    def as_type(self, status_format: StatusFormats) -> Union[int, float, str]:
-        """
-        Get the generation state in a given format.
-
-        >>> chunk.status.as_type(StatusFormats.Raw)
-        2.0
-        >>> chunk.status.as_type(StatusFormats.Bedrock)
-        2
-        >>> chunk.status.as_type(StatusFormats.Java_14)
-        'full'
-
-        :param status_format: The format the status should be returned in. Must be from :class:`StatusFormats`.
-        :return: The status code in the requested format.
-        """
-        if not isinstance(status_format, StatusFormats):
-            raise ValueError("Version must be one of the states of StatusFormats")
-
-        if status_format == StatusFormats.Raw:
-            return self._value
-        elif status_format == StatusFormats.Bedrock:  # Bedrock (0, 1 or 2)
-            return int(max(min(2, self._value), 0))
-        elif status_format in versions:  # Java 1.13/1.14
-            value = next(
-                (v for v in versions[status_format] if v[0] <= self._value), None
-            )
-            if value is None:
-                value = next((v for v in versions[status_format] if v[0] <= 2.0), None)
-            return value[1]
-        else:
-            raise ValueError(f"Unsupported status format {status_format}")
+from typing import Union, Dict, List, Tuple
+from enum import Enum
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class StatusFormats(Enum):
+    """
+    The different formats the status value can be converted to.
+
+    >>> StatusFormats.Raw  # The raw float value
+    >>> StatusFormats.Bedrock  # as an integer between 0 and 2
+    >>> StatusFormats.Java_13  # as a string
+    >>> StatusFormats.Java_14  # as a string
+    """
+
+    Raw = 0  # The raw float value
+    Bedrock = 1  # as an integer between 0 and 2
+    Java_13 = 2  # as a string
+    Java_14 = 3  # as a string
+    Java_20 = 20  # as a string
+
+
+J13 = StatusFormats.Java_13
+J14 = StatusFormats.Java_14
+J20 = StatusFormats.Java_20
+
+states = {
+    "empty": [[J13, J14], -1],
+    "minecraft:empty": [[J20], -1],
+    "structure_starts": [[J14], -0.9],
+    "minecraft:structure_starts": [[J20], -0.9],
+    "structure_references": [[J14], -0.8],
+    "minecraft:structure_references": [[J20], -0.8],
+    "biomes": [[J14], -0.7],
+    "minecraft:biomes": [[J20], -0.7],
+    "noise": [[J14], -0.6],
+    "minecraft:noise": [[J20], -0.6],
+    "base": [[J13], -0.5],
+    "surface": [[J14], -0.5],
+    "minecraft:surface": [[J20], -0.5],
+    "carved": [[J13], -0.4],
+    "carvers": [[J14], -0.4],
+    "minecraft:carvers": [[J20], -0.4],
+    "liquid_carved": [[J13], -0.3],
+    "liquid_carvers": [[J14], -0.3],
+    "decorated": [[J13], -0.2],
+    "features": [[J14], -0.2],
+    "minecraft:features": [[J20], -0.2],
+    "lighted": [[J13], -0.1],
+    "minecraft:initialize_light": [[J20], -0.1],
+    "light": [[J14], -0.1],
+    "minecraft:light": [[J20], -0.1],
+    # 0.0	needs ticked
+    # 1.0	needs population
+    "mobs_spawned": [[J13], 1.1],
+    "spawn": [[J14], 1.1],
+    "minecraft:spawn": [[J20], 1.1],
+    "finalized": [[J13], 1.5],
+    "heightmaps": [[J14], 1.5],
+    "fullchunk": [[J13], 1.9],
+    "postprocessed": [[J13], 2.0],
+    "full": [[J14], 2.0],
+    "minecraft:full": [[J20], 2.0],
+    # 2.0	done
+}
+
+versions: Dict[StatusFormats, List[Tuple[float, str]]] = {}
+for key, val in states.items():
+    for version_ in val[0]:
+        versions.setdefault(version_, []).append((val[1], key))
+for data in versions.values():
+    data.sort(key=lambda val_: val_[0], reverse=True)
+
+
+class Status:
+    """
+    A class to represent the generation state of a chunk.
+
+    This stores the chunk status as a float in the range -1 to 2 where -1 is nothing generated and 2 being fully generated.
+    """
+
+    def __init__(self):
+        """
+        Construct an instance of the :class:`Status` class.
+        """
+        self._value = 2.0
+
+    @property
+    def value(self) -> float:
+        """
+        **Getter**
+
+        Get the raw status value.
+
+        >>> status = chunk.status.value
+
+        :return: The float status value in the range -1 to 2
+
+        **Setter**
+
+        Set the status value.
+
+        >>> chunk.status.value = 2
+        >>> chunk.status.value = "full"
+
+        This can be a float/int or a string. If it is a string it is looked up in the states look up table to find the float value it corresponds with.
+
+        :param value: The value to set as the generation stage.
+        """
+        return self._value
+
+    @value.setter
+    def value(self, value: Union[float, int, str]):
+        """
+        Set the status value.
+
+        >>> chunk.status.value = 2
+        >>> chunk.status.value = "full"
+
+        This can be a float/int or a string. If it is a string it is looked up in the states look up table to find the float value it corresponds with.
+
+        :param value: The value to set as the generation stage.
+        """
+        if isinstance(value, float):
+            self._value = value
+        elif isinstance(value, int):
+            self._value = float(value)
+        elif isinstance(value, str) and value in states:
+            self._value = states[value][1]
+        else:
+            log.error(
+                f"Unrecognised chunk state {value}. Defaulting to fully generated.\nIf this is a new version report it to the developers."
+            )
+            self._value = 2.0
+
+    def as_type(self, status_format: StatusFormats) -> Union[int, float, str]:
+        """
+        Get the generation state in a given format.
+
+        >>> chunk.status.as_type(StatusFormats.Raw)
+        2.0
+        >>> chunk.status.as_type(StatusFormats.Bedrock)
+        2
+        >>> chunk.status.as_type(StatusFormats.Java_14)
+        'full'
+
+        :param status_format: The format the status should be returned in. Must be from :class:`StatusFormats`.
+        :return: The status code in the requested format.
+        """
+        if not isinstance(status_format, StatusFormats):
+            raise ValueError("Version must be one of the states of StatusFormats")
+
+        if status_format == StatusFormats.Raw:
+            return self._value
+        elif status_format == StatusFormats.Bedrock:  # Bedrock (0, 1 or 2)
+            return int(max(min(2, self._value), 0))
+        elif status_format in versions:  # Java 1.13/1.14
+            value = next(
+                (v for v in versions[status_format] if v[0] <= self._value), None
+            )
+            if value is None:
+                value = next((v for v in versions[status_format] if v[0] <= 2.0), None)
+            return value[1]
+        else:
+            raise ValueError(f"Unsupported status format {status_format}")

amulet/api/data_types/__init__.py

@@ -1,4 +1,4 @@
-from .world_types import *
-from .wrapper_types import *
-from .operation_types import *
-from .generic_types import *
+from .world_types import *
+from .wrapper_types import *
+from .operation_types import *
+from .generic_types import *

amulet/api/data_types/generic_types.py

@@ -1,4 +1,4 @@
-from typing import Union
-from numpy import integer
-
-Int = Union[int, integer]
+from typing import Union
+from numpy import integer
+
+Int = Union[int, integer]

amulet/api/data_types/operation_types.py

@@ -1,16 +1,16 @@
-from typing import Any, Union, Generator, Callable, Tuple, TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from amulet.api.level import BaseLevel
-    from .world_types import Dimension
-
-# Operation types
-
-#: The data type that an operation is able to yield.
-OperationYieldType = Union[int, float, Tuple[Union[int, float], str]]
-
-#: The data type that an operation is able to return.
-OperationReturnType = Optional[Union[Generator[OperationYieldType, None, Any], Any]]
-
-#: The data type for an operation callable object.
-OperationType = Callable[["BaseLevel", "Dimension", Any], OperationReturnType]
+from typing import Any, Union, Generator, Callable, Tuple, TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from amulet.api.level import BaseLevel
+    from .world_types import Dimension
+
+# Operation types
+
+#: The data type that an operation is able to yield.
+OperationYieldType = Union[int, float, Tuple[Union[int, float], str]]
+
+#: The data type that an operation is able to return.
+OperationReturnType = Optional[Union[Generator[OperationYieldType, None, Any], Any]]
+
+#: The data type for an operation callable object.
+OperationType = Callable[["BaseLevel", "Dimension", Any], OperationReturnType]

amulet/api/data_types/world_types.py

@@ -1,49 +1,49 @@
-from typing import Union, Tuple
-import numpy
-
-# from nptyping import NDArray
-
-#: The data type for a Tuple containing three floats. Use :data:`PointCoordinates` for x, y, z float coordinates.
-FloatTriplet = Tuple[float, float, float]
-
-#: The data type for the dimension identifier.
-Dimension = str
-
-#: The data type for the x and z coordinates of a region file. Note these are no the same as block coordinates.
-RegionCoordinates = 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 = 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 = Tuple[int, int, int]
-
-#: The data type for the dimension and x and z coordinates of a chunk within a world. Note these are no the same as block coordinates.
-DimensionCoordinates = Tuple[Dimension, int, int]
-
-#: The data type for the x, y and z location of a block within the world.
-BlockCoordinates = 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.
-BlockCoordinatesNDArray = numpy.ndarray  # NDArray[(3, ), int]
-
-#: The data type for the x, y and z location of a block within the world in either tuple or numpy array form.
-BlockCoordinatesAny = Union[BlockCoordinates, BlockCoordinatesNDArray]
-
-#: The data type for the x, y and z location of a point within the world.
-PointCoordinates = FloatTriplet
-
-#: The data type for the x, y and z location of a point within the world in the form of a numpy array.
-PointCoordinatesNDArray = numpy.ndarray  # NDArray[(3, ), numpy.float]
-
-#: The data type for the x, y and z location of a point within the world in either tuple or numpy array form.
-PointCoordinatesAny = Union[PointCoordinates, PointCoordinatesNDArray]
-
-#: The data type for x, y and z location in either float or int and tuple or numpy array format.
-CoordinatesAny = Union[BlockCoordinatesAny, PointCoordinatesAny]
-
-#: The data type for a sub-chunk array. This array should be a 16x16x16 numpy array.
-SubChunkNDArray = numpy.ndarray  # NDArray[(16, 16, 16), numpy.uint32]
-
-#: The data type for a biome string identifier.
-BiomeType = str
+from typing import Union, Tuple
+import numpy
+
+# from nptyping import NDArray
+
+#: The data type for a Tuple containing three floats. Use :data:`PointCoordinates` for x, y, z float coordinates.
+FloatTriplet = Tuple[float, float, float]
+
+#: The data type for the dimension identifier.
+Dimension = str
+
+#: The data type for the x and z coordinates of a region file. Note these are no the same as block coordinates.
+RegionCoordinates = 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 = 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 = Tuple[int, int, int]
+
+#: The data type for the dimension and x and z coordinates of a chunk within a world. Note these are no the same as block coordinates.
+DimensionCoordinates = Tuple[Dimension, int, int]
+
+#: The data type for the x, y and z location of a block within the world.
+BlockCoordinates = 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.
+BlockCoordinatesNDArray = numpy.ndarray  # NDArray[(3, ), int]
+
+#: The data type for the x, y and z location of a block within the world in either tuple or numpy array form.
+BlockCoordinatesAny = Union[BlockCoordinates, BlockCoordinatesNDArray]
+
+#: The data type for the x, y and z location of a point within the world.
+PointCoordinates = FloatTriplet
+
+#: The data type for the x, y and z location of a point within the world in the form of a numpy array.
+PointCoordinatesNDArray = numpy.ndarray  # NDArray[(3, ), numpy.float]
+
+#: The data type for the x, y and z location of a point within the world in either tuple or numpy array form.
+PointCoordinatesAny = Union[PointCoordinates, PointCoordinatesNDArray]
+
+#: The data type for x, y and z location in either float or int and tuple or numpy array format.
+CoordinatesAny = Union[BlockCoordinatesAny, PointCoordinatesAny]
+
+#: The data type for a sub-chunk array. This array should be a 16x16x16 numpy array.
+SubChunkNDArray = numpy.ndarray  # NDArray[(16, 16, 16), numpy.uint32]
+
+#: The data type for a biome string identifier.
+BiomeType = str