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

amulet/api/partial_3d_array/util.py

@@ -1,152 +1,152 @@
-import math
-from typing import Optional, Tuple
-
-from .data_types import (
-    FlexibleSlicesType,
-    SliceSlicesType,
-    Integer,
-    SingleFlexibleSliceType,
-)
-
-
-def _sanitise_slice(start: int, stop: int, step: int) -> Tuple[int, int, int]:
-    step_count = math.ceil(max((stop - start) / step, 0))
-    stop = start + step_count * step
-    if step_count:
-        stop += int(math.copysign(1, step)) - step
-
-    return start, stop, step
-
-
-def sanitise_slice(
-    start: Optional[int], stop: Optional[int], step: Optional[int], arr_size: int
-) -> Tuple[int, int, int]:
-    """
-    Convert slices into a sane format
-    0 is always before the first number and arr_size is always after the last number.
-    """
-    # set default values
-    if step is None:
-        step = 1
-    elif step == 0:
-        raise Exception("step cannot be 0")
-
-    if start is None:
-        if step > 0:
-            start = 0
-        else:
-            start = arr_size - 1
-    elif start < 0:
-        start = arr_size + start
-
-    if stop is None:
-        if step > 0:
-            stop = arr_size
-        else:
-            stop = -1
-    elif stop < 0:
-        stop = arr_size + stop
-
-    if step < 0:
-        start += 1
-        stop += 1
-
-    # cap at the ends
-    if step > 0:
-        start = max(0, start)
-        stop = min(stop, arr_size)
-    elif step < 0:
-        start = min(arr_size, start)
-        stop = max(stop, 0)
-
-    return _sanitise_slice(start, stop, step)
-
-
-def sanitise_unbounded_slice(
-    start: Optional[int],
-    stop: Optional[int],
-    step: Optional[int],
-    default_min: int,  # the minimum value to default to
-    default_max: int,  # the maximum value to default to
-) -> Tuple[int, int, int]:
-    if step is None:
-        step = 1
-    elif step == 0:
-        raise Exception("step cannot be 0")
-
-    # cap at the normal limits
-    if step > 0:
-        if start is None:
-            start = default_min
-        if stop is None:
-            stop = default_max
-    else:
-        if start is None:
-            start = default_max
-        if stop is None:
-            stop = default_min
-
-    if step < 0:
-        start += 1
-        stop += 1
-
-    return _sanitise_slice(start, stop, step)
-
-
-def unsanitise_slice(
-    start: int, stop: int, step: int, arr_size: int
-) -> Tuple[int, int, int]:
-    """Convert sanitised slices back to the normal format."""
-    if step < 0:
-        start -= 1
-        stop -= 1
-        if start < 0:
-            start -= arr_size
-        if stop < 0:
-            stop -= arr_size
-
-    return start, stop, step
-
-
-def stack_sanitised_slices(
-    start1: int, stop1: int, step1: int, start2: int, stop2: int, step2: int
-) -> Tuple[int, int, int]:
-    step3 = step1 * step2
-    start3 = start1 + start2 * step1
-    stop3 = start1 + stop2 * step1
-
-    return _sanitise_slice(start3, stop3, step3)
-
-
-def unpack_slice(item: slice):
-    return item.start, item.stop, item.step
-
-
-def to_slice(item: SingleFlexibleSliceType) -> slice:
-    if isinstance(item, Integer):
-        item = int(item)
-        return slice(item, item + 1, 1)
-    elif isinstance(item, slice):
-        step = item.step
-        if step == 0:
-            raise Exception("Step of 0 is invalid")
-        return slice(item.start, item.stop, 1 if step is None else step)
-    else:
-        raise Exception(f"Unsupported slice item {item}")
-
-
-def multi_to_slice(slices: FlexibleSlicesType) -> SliceSlicesType:
-    return tuple(to_slice(item) for item in slices)
-
-
-def get_sliced_array_size(
-    start: Optional[int], stop: Optional[int], step: Optional[int], arr_size
-) -> int:
-    """Find the size of the array the slice would produce from an array of size arr_size"""
-    start, stop, step = sanitise_slice(start, stop, step, arr_size)
-    return get_sanitised_sliced_array_size(start, stop, step)
-
-
-def get_sanitised_sliced_array_size(start: int, stop: int, step: int):
-    """Find the size of a slice that has been pre-sanitised"""
-    return math.ceil((stop - start) / step)
+import math
+from typing import Optional, Tuple
+
+from .data_types import (
+    FlexibleSlicesType,
+    SliceSlicesType,
+    Integer,
+    SingleFlexibleSliceType,
+)
+
+
+def _sanitise_slice(start: int, stop: int, step: int) -> Tuple[int, int, int]:
+    step_count = math.ceil(max((stop - start) / step, 0))
+    stop = start + step_count * step
+    if step_count:
+        stop += int(math.copysign(1, step)) - step
+
+    return start, stop, step
+
+
+def sanitise_slice(
+    start: Optional[int], stop: Optional[int], step: Optional[int], arr_size: int
+) -> Tuple[int, int, int]:
+    """
+    Convert slices into a sane format
+    0 is always before the first number and arr_size is always after the last number.
+    """
+    # set default values
+    if step is None:
+        step = 1
+    elif step == 0:
+        raise Exception("step cannot be 0")
+
+    if start is None:
+        if step > 0:
+            start = 0
+        else:
+            start = arr_size - 1
+    elif start < 0:
+        start = arr_size + start
+
+    if stop is None:
+        if step > 0:
+            stop = arr_size
+        else:
+            stop = -1
+    elif stop < 0:
+        stop = arr_size + stop
+
+    if step < 0:
+        start += 1
+        stop += 1
+
+    # cap at the ends
+    if step > 0:
+        start = max(0, start)
+        stop = min(stop, arr_size)
+    elif step < 0:
+        start = min(arr_size, start)
+        stop = max(stop, 0)
+
+    return _sanitise_slice(start, stop, step)
+
+
+def sanitise_unbounded_slice(
+    start: Optional[int],
+    stop: Optional[int],
+    step: Optional[int],
+    default_min: int,  # the minimum value to default to
+    default_max: int,  # the maximum value to default to
+) -> Tuple[int, int, int]:
+    if step is None:
+        step = 1
+    elif step == 0:
+        raise Exception("step cannot be 0")
+
+    # cap at the normal limits
+    if step > 0:
+        if start is None:
+            start = default_min
+        if stop is None:
+            stop = default_max
+    else:
+        if start is None:
+            start = default_max
+        if stop is None:
+            stop = default_min
+
+    if step < 0:
+        start += 1
+        stop += 1
+
+    return _sanitise_slice(start, stop, step)
+
+
+def unsanitise_slice(
+    start: int, stop: int, step: int, arr_size: int
+) -> Tuple[int, int, int]:
+    """Convert sanitised slices back to the normal format."""
+    if step < 0:
+        start -= 1
+        stop -= 1
+        if start < 0:
+            start -= arr_size
+        if stop < 0:
+            stop -= arr_size
+
+    return start, stop, step
+
+
+def stack_sanitised_slices(
+    start1: int, stop1: int, step1: int, start2: int, stop2: int, step2: int
+) -> Tuple[int, int, int]:
+    step3 = step1 * step2
+    start3 = start1 + start2 * step1
+    stop3 = start1 + stop2 * step1
+
+    return _sanitise_slice(start3, stop3, step3)
+
+
+def unpack_slice(item: slice):
+    return item.start, item.stop, item.step
+
+
+def to_slice(item: SingleFlexibleSliceType) -> slice:
+    if isinstance(item, Integer):
+        item = int(item)
+        return slice(item, item + 1, 1)
+    elif isinstance(item, slice):
+        step = item.step
+        if step == 0:
+            raise Exception("Step of 0 is invalid")
+        return slice(item.start, item.stop, 1 if step is None else step)
+    else:
+        raise Exception(f"Unsupported slice item {item}")
+
+
+def multi_to_slice(slices: FlexibleSlicesType) -> SliceSlicesType:
+    return tuple(to_slice(item) for item in slices)
+
+
+def get_sliced_array_size(
+    start: Optional[int], stop: Optional[int], step: Optional[int], arr_size
+) -> int:
+    """Find the size of the array the slice would produce from an array of size arr_size"""
+    start, stop, step = sanitise_slice(start, stop, step, arr_size)
+    return get_sanitised_sliced_array_size(start, stop, step)
+
+
+def get_sanitised_sliced_array_size(start: int, stop: int, step: int):
+    """Find the size of a slice that has been pre-sanitised"""
+    return math.ceil((stop - start) / step)

amulet/api/player.py

@@ -1,65 +1,65 @@
-from __future__ import annotations
-
-from typing import Tuple
-
-from amulet.api.history import Changeable
-from amulet.api.data_types import Dimension
-
-LOCAL_PLAYER = "~local_player"
-
-
-class Player(Changeable):
-    def __init__(
-        self,
-        player_id: str,
-        dimension: str,
-        location: Tuple[float, float, float],
-        rotation: Tuple[float, float],
-    ):
-        """
-        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: 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 = dimension
-
-    def __repr__(self):
-        return f"Player({self.player_id}, {self.dimension}, {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(self) -> Dimension:
-        """The current dimension the player is in"""
-        return self._dimension
+from __future__ import annotations
+
+from typing import Tuple
+
+from amulet.api.history import Changeable
+from amulet.api.data_types import Dimension
+
+LOCAL_PLAYER = "~local_player"
+
+
+class Player(Changeable):
+    def __init__(
+        self,
+        player_id: str,
+        dimension: str,
+        location: Tuple[float, float, float],
+        rotation: Tuple[float, float],
+    ):
+        """
+        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: 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 = dimension
+
+    def __repr__(self):
+        return f"Player({self.player_id}, {self.dimension}, {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(self) -> Dimension:
+        """The current dimension the player is in"""
+        return self._dimension

amulet/api/registry/__init__.py

@@ -1,2 +1,2 @@
-from .biome_manager import BiomeManager
-from .block_manager import BlockManager
+from .biome_manager import BiomeManager
+from .block_manager import BlockManager

amulet/api/registry/base_registry.py

@@ -1,34 +1,34 @@
-from abc import ABC, abstractmethod
-from typing import Union, Tuple, Generator, Iterable, Any
-
-BaseType = Any
-
-
-class BaseRegistry(ABC):
-    @abstractmethod
-    def __len__(self):
-        raise NotImplementedError
-
-    @abstractmethod
-    def __contains__(self, item: Union[int, BaseType]):
-        raise NotImplementedError
-
-    @abstractmethod
-    def __iter__(self) -> Iterable[BaseType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def values(self) -> Tuple[BaseType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def items(self) -> Generator[Tuple[int, BaseType], None, None]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def __getitem__(self, item):
-        raise NotImplementedError
-
-    @abstractmethod
-    def register(self, item: BaseType) -> int:
-        raise NotImplementedError
+from abc import ABC, abstractmethod
+from typing import Union, Tuple, Generator, Iterable, Any
+
+BaseType = Any
+
+
+class BaseRegistry(ABC):
+    @abstractmethod
+    def __len__(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def __contains__(self, item: Union[int, BaseType]):
+        raise NotImplementedError
+
+    @abstractmethod
+    def __iter__(self) -> Iterable[BaseType]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def values(self) -> Tuple[BaseType]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def items(self) -> Generator[Tuple[int, BaseType], None, None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __getitem__(self, item):
+        raise NotImplementedError
+
+    @abstractmethod
+    def register(self, item: BaseType) -> int:
+        raise NotImplementedError