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

amulet/api/data_types/wrapper_types.py

@@ -1,71 +1,71 @@
-from typing import Union, Callable, Tuple, Optional, TYPE_CHECKING, List
-import numpy
-
-if TYPE_CHECKING:
-    from .world_types import BlockCoordinates
-    from amulet.api.chunk import Chunk
-    from amulet.api.block import Block
-    from amulet.api.block_entity import BlockEntity
-    from amulet.api.entity import Entity
-
-# Wrapper types
-BlockNDArray = numpy.ndarray  # NDArray[(Any, ), 'Block']
-AnyNDArray = numpy.ndarray  # NDArray[(Any, ), Any]
-
-#: The data type for the platform identifier.
-PlatformType = str
-
-#: The data type for an integer version number.
-VersionNumberInt = int
-
-#: The data type for the tuple version number.
-VersionNumberTuple = Tuple[int, ...]
-
-#: The data type for either an integer or tuple version number.
-VersionNumberAny = Union[VersionNumberInt, VersionNumberTuple]
-
-#: The data type for a version identifier containing platform and int or tuple version number
-VersionIdentifierType = Tuple[PlatformType, VersionNumberAny]
-#: The data type for a version identifier containing platform and int version number
-VersionIdentifierInt = Tuple[PlatformType, VersionNumberInt]
-#: The data type for a version identifier containing platform and tuple version number
-VersionIdentifierTuple = Tuple[PlatformType, VersionNumberTuple]
-
-GetChunkCallback = Callable[[int, int], "Chunk"]
-
-BedrockInterfaceBlockType = Tuple[
-    Union[Tuple[None, Tuple[int, int]], Tuple[None, "Block"], Tuple[int, "Block"]], ...
-]
-
-GetBlockCallback = Callable[  # get a block at a different location
-    [
-        "BlockCoordinates"
-    ],  # this takes the coordinates relative to the block in question
-    Tuple[
-        "Block", Optional["BlockEntity"]
-    ],  # and returns a new block and optionally a block entity
-]
-
-TranslateBlockCallbackReturn = Tuple[
-    Optional["Block"], Optional["BlockEntity"], List["Entity"], bool
-]
-
-TranslateEntityCallbackReturn = Tuple[
-    Optional["Block"], Optional["BlockEntity"], List["Entity"]
-]
-
-TranslateBlockCallback = Callable[
-    [  # a callable
-        "Block",  # that takes either a Block
-        Optional[
-            GetBlockCallback
-        ],  # this is used in cases where the block needs data beyond itself to fully define itself (eg doors)
-        "BlockCoordinates",  # used in a select few cases where the translation needs to know where the block is
-    ],
-    TranslateBlockCallbackReturn,  # ultimately return the converted objects(s)
-]
-
-TranslateEntityCallback = Callable[
-    ["Entity"],  # a callable  # that takes either an Entity
-    TranslateEntityCallbackReturn,  # ultimately return the converted objects(s)
-]
+from typing import Union, Callable, Tuple, Optional, TYPE_CHECKING, List
+import numpy
+
+if TYPE_CHECKING:
+    from .world_types import BlockCoordinates
+    from amulet.api.chunk import Chunk
+    from amulet.api.block import Block
+    from amulet.api.block_entity import BlockEntity
+    from amulet.api.entity import Entity
+
+# Wrapper types
+BlockNDArray = numpy.ndarray  # NDArray[(Any, ), 'Block']
+AnyNDArray = numpy.ndarray  # NDArray[(Any, ), Any]
+
+#: The data type for the platform identifier.
+PlatformType = str
+
+#: The data type for an integer version number.
+VersionNumberInt = int
+
+#: The data type for the tuple version number.
+VersionNumberTuple = Tuple[int, ...]
+
+#: The data type for either an integer or tuple version number.
+VersionNumberAny = Union[VersionNumberInt, VersionNumberTuple]
+
+#: The data type for a version identifier containing platform and int or tuple version number
+VersionIdentifierType = Tuple[PlatformType, VersionNumberAny]
+#: The data type for a version identifier containing platform and int version number
+VersionIdentifierInt = Tuple[PlatformType, VersionNumberInt]
+#: The data type for a version identifier containing platform and tuple version number
+VersionIdentifierTuple = Tuple[PlatformType, VersionNumberTuple]
+
+GetChunkCallback = Callable[[int, int], "Chunk"]
+
+BedrockInterfaceBlockType = Tuple[
+    Union[Tuple[None, Tuple[int, int]], Tuple[None, "Block"], Tuple[int, "Block"]], ...
+]
+
+GetBlockCallback = Callable[  # get a block at a different location
+    [
+        "BlockCoordinates"
+    ],  # this takes the coordinates relative to the block in question
+    Tuple[
+        "Block", Optional["BlockEntity"]
+    ],  # and returns a new block and optionally a block entity
+]
+
+TranslateBlockCallbackReturn = Tuple[
+    Optional["Block"], Optional["BlockEntity"], List["Entity"], bool
+]
+
+TranslateEntityCallbackReturn = Tuple[
+    Optional["Block"], Optional["BlockEntity"], List["Entity"]
+]
+
+TranslateBlockCallback = Callable[
+    [  # a callable
+        "Block",  # that takes either a Block
+        Optional[
+            GetBlockCallback
+        ],  # this is used in cases where the block needs data beyond itself to fully define itself (eg doors)
+        "BlockCoordinates",  # used in a select few cases where the translation needs to know where the block is
+    ],
+    TranslateBlockCallbackReturn,  # ultimately return the converted objects(s)
+]
+
+TranslateEntityCallback = Callable[
+    ["Entity"],  # a callable  # that takes either an Entity
+    TranslateEntityCallbackReturn,  # ultimately return the converted objects(s)
+]

amulet/api/entity.py

@@ -1,74 +1,74 @@
-from __future__ import annotations
-
-import numpy
-from typing import Tuple, Union
-from amulet_nbt import NamedTag
-from .abstract_base_entity import AbstractBaseEntity
-
-
-class Entity(AbstractBaseEntity):
-    """
-    A class to contain all the data to define an Entity.
-    """
-
-    obj_name = "Entity"
-    coord_types = (float, numpy.floating)
-
-    def __init__(
-        self,
-        namespace: str,
-        base_name: str,
-        x: float,
-        y: float,
-        z: float,
-        nbt: NamedTag,
-    ):
-        """
-        Constructs a :class:`Entity` instance.
-
-        :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__(namespace, base_name, x, y, z, nbt)
-
-    @property
-    def x(self) -> float:
-        """The x location of the Entity."""
-        return self._x
-
-    @x.setter
-    def x(self, value: float):
-        self._x = value
-
-    @property
-    def y(self) -> float:
-        """The y location of the Entity."""
-        return self._y
-
-    @y.setter
-    def y(self, value: float):
-        self._y = value
-
-    @property
-    def z(self) -> float:
-        """The z location of the Entity."""
-        return self._z
-
-    @z.setter
-    def z(self, value: float):
-        self._z = value
-
-    @property
-    def location(self) -> Tuple[float, float, float]:
-        """The location of the Entity."""
-        return self._x, self._y, self._z
-
-    @location.setter
-    def location(
-        self, location: Tuple[Union[int, float], Union[int, float], Union[int, float]]
-    ):
-        self._x, self._y, self._z = location
+from __future__ import annotations
+
+import numpy
+from typing import Tuple, Union
+from amulet_nbt import NamedTag
+from .abstract_base_entity import AbstractBaseEntity
+
+
+class Entity(AbstractBaseEntity):
+    """
+    A class to contain all the data to define an Entity.
+    """
+
+    obj_name = "Entity"
+    coord_types = (float, numpy.floating)
+
+    def __init__(
+        self,
+        namespace: str,
+        base_name: str,
+        x: float,
+        y: float,
+        z: float,
+        nbt: NamedTag,
+    ):
+        """
+        Constructs a :class:`Entity` instance.
+
+        :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__(namespace, base_name, x, y, z, nbt)
+
+    @property
+    def x(self) -> float:
+        """The x location of the Entity."""
+        return self._x
+
+    @x.setter
+    def x(self, value: float):
+        self._x = value
+
+    @property
+    def y(self) -> float:
+        """The y location of the Entity."""
+        return self._y
+
+    @y.setter
+    def y(self, value: float):
+        self._y = value
+
+    @property
+    def z(self) -> float:
+        """The z location of the Entity."""
+        return self._z
+
+    @z.setter
+    def z(self, value: float):
+        self._z = value
+
+    @property
+    def location(self) -> Tuple[float, float, float]:
+        """The location of the Entity."""
+        return self._x, self._y, self._z
+
+    @location.setter
+    def location(
+        self, location: Tuple[Union[int, float], Union[int, float], Union[int, float]]
+    ):
+        self._x, self._y, self._z = location

amulet/api/errors.py

@@ -1,119 +1,119 @@
-class FormatError(Exception):
-    """A base error for all errors related to the :class:`~amulet.api.wrapper.format_wrapper.FormatWrapper` class."""
-
-    pass
-
-
-class LoaderNoneMatched(FormatError):
-    """An error thrown if no loader could be found that could load the given data."""
-
-    pass
-
-
-class BlockException(Exception):
-    """An error thrown by the :class:`~amulet.api.block.Block` class."""
-
-    pass
-
-
-class EntryLoadError(Exception):
-    pass
-
-
-class EntryDoesNotExist(EntryLoadError):
-    pass
-
-
-class PlayerLoadError(EntryLoadError):
-    """
-    An error thrown if a player failed to load for some reason.
-    """
-
-    pass
-
-
-class PlayerDoesNotExist(EntryDoesNotExist, PlayerLoadError):
-    """
-    An error thrown if a player does not exist.
-    """
-
-    pass
-
-
-class ChunkLoadError(EntryLoadError):
-    """
-    An error thrown if a chunk failed to load for some reason.
-
-    This may be due to a corrupt chunk, an unsupported chunk format or just because the chunk does not exist to be loaded.
-
-    Catching this error will also catch :class:`ChunkDoesNotExist`
-
-    >>> try:
-    >>>     # get chunk
-    >>>     chunk = world.get_chunk(cx, cz, dimension)
-    >>> except ChunkLoadError:
-    >>>     # will catch all chunks that have failed to load
-    >>>     # either because they do not exist or errored during loading.
-    """
-
-    pass
-
-
-class ChunkDoesNotExist(EntryDoesNotExist, ChunkLoadError):
-    """
-    An error thrown if a chunk does not exist and therefor cannot be loaded.
-
-    >>> try:
-    >>>     # get chunk
-    >>>     chunk = world.get_chunk(cx, cz, dimension)
-    >>> except ChunkDoesNotExist:
-    >>>     # will catch all chunks that do not exist
-    >>>     # will not catch corrupt chunks
-    >>> except ChunkLoadError:
-    >>>     # will only catch chunks that errored during loading
-    >>>     # chunks that do not exist were caught by the previous except section.
-    """
-
-    pass
-
-
-class ChunkSaveError(Exception):
-    """An error thrown if there was an error during the chunk saving process."""
-
-    pass
-
-
-class DimensionDoesNotExist(Exception):
-    """An error thrown if trying to load data from a dimension that does not exist."""
-
-    pass
-
-
-class ObjectReadWriteError(Exception):
-    """
-    An error thrown when the raw level data cannot be read from or written to.
-
-    This is usually because the data has been opened somewhere else.
-    """
-
-    pass
-
-
-class ObjectReadError(ObjectReadWriteError):
-    """
-    An error thrown when the raw level data cannot be read from.
-
-    This is usually because the data has been opened somewhere else.
-    """
-
-    pass
-
-
-class ObjectWriteError(ObjectReadWriteError):
-    """
-    An error thrown when the raw level data cannot be written to.
-
-    This is usually because the data has been opened somewhere else.
-    """
-
-    pass
+class FormatError(Exception):
+    """A base error for all errors related to the :class:`~amulet.api.wrapper.format_wrapper.FormatWrapper` class."""
+
+    pass
+
+
+class LoaderNoneMatched(FormatError):
+    """An error thrown if no loader could be found that could load the given data."""
+
+    pass
+
+
+class BlockException(Exception):
+    """An error thrown by the :class:`~amulet.api.block.Block` class."""
+
+    pass
+
+
+class EntryLoadError(Exception):
+    pass
+
+
+class EntryDoesNotExist(EntryLoadError):
+    pass
+
+
+class PlayerLoadError(EntryLoadError):
+    """
+    An error thrown if a player failed to load for some reason.
+    """
+
+    pass
+
+
+class PlayerDoesNotExist(EntryDoesNotExist, PlayerLoadError):
+    """
+    An error thrown if a player does not exist.
+    """
+
+    pass
+
+
+class ChunkLoadError(EntryLoadError):
+    """
+    An error thrown if a chunk failed to load for some reason.
+
+    This may be due to a corrupt chunk, an unsupported chunk format or just because the chunk does not exist to be loaded.
+
+    Catching this error will also catch :class:`ChunkDoesNotExist`
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkLoadError:
+    >>>     # will catch all chunks that have failed to load
+    >>>     # either because they do not exist or errored during loading.
+    """
+
+    pass
+
+
+class ChunkDoesNotExist(EntryDoesNotExist, ChunkLoadError):
+    """
+    An error thrown if a chunk does not exist and therefor cannot be loaded.
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkDoesNotExist:
+    >>>     # will catch all chunks that do not exist
+    >>>     # will not catch corrupt chunks
+    >>> except ChunkLoadError:
+    >>>     # will only catch chunks that errored during loading
+    >>>     # chunks that do not exist were caught by the previous except section.
+    """
+
+    pass
+
+
+class ChunkSaveError(Exception):
+    """An error thrown if there was an error during the chunk saving process."""
+
+    pass
+
+
+class DimensionDoesNotExist(Exception):
+    """An error thrown if trying to load data from a dimension that does not exist."""
+
+    pass
+
+
+class ObjectReadWriteError(Exception):
+    """
+    An error thrown when the raw level data cannot be read from or written to.
+
+    This is usually because the data has been opened somewhere else.
+    """
+
+    pass
+
+
+class ObjectReadError(ObjectReadWriteError):
+    """
+    An error thrown when the raw level data cannot be read from.
+
+    This is usually because the data has been opened somewhere else.
+    """
+
+    pass
+
+
+class ObjectWriteError(ObjectReadWriteError):
+    """
+    An error thrown when the raw level data cannot be written to.
+
+    This is usually because the data has been opened somewhere else.
+    """
+
+    pass

amulet/api/history/__init__.py

@@ -1,36 +1,36 @@
-"""
-local history manager
-    key based storage
-        When a piece of data is loaded from disk it needs to be stored as revision 0
-        If a piece of data is deleted it should be stored as None to specify that the data has been deleted
-        If a piece of data was created rather than loaded from disk the revision 0 should be populated as None
-            to specify that the revision 0 did not exist and the data should be added as revision 1
-        It needs to store the revision index that is current within the editor.
-        It also needs to store the revision that is saved to disk so that we know what has changed compared to
-            the current save state rather than the original save state.
-        If the above two indexes do not match then the data has been changed compared to the saved version so it needs saving.
-    global storage
-        We need to store a list of pools of keys that have changed for each undo point.
-        We also need to store the index of which pool is current. This will get changed when undoing/redoing to keep track.
-
-
-    When the creation of an undo point is requested
-        we should scan all of the objects and see if the `changed` flag has been set to `True`.
-        If this is the case the data has been changed and we should create a backup of it.
-            make sure to reset the `changed` flag to False for the cached version
-        A new revision for each entry is created and the current revision index is incremented.
-        A pool of keys that have changed should be created.
-            When undoing this change we look at this pool to see what changed and undo each of those.
-            The same applies when redoing
-        Finally the `changed` flags for each of the entries should be changed to False so that the next
-            undo point only catches what has changed since this undo point.
-            The better solution here is to empty the temporary database and re-populate from the latest cache
-                revision where the `changed` flag was already set to False. This also solves the issue where
-                the data was modified but the `changed` flag was not set to True by the script.
-
-global history manager
-    would store each of the local history managers
-    would be the entry
-"""
-
-from .changeable import Changeable
+"""
+local history manager
+    key based storage
+        When a piece of data is loaded from disk it needs to be stored as revision 0
+        If a piece of data is deleted it should be stored as None to specify that the data has been deleted
+        If a piece of data was created rather than loaded from disk the revision 0 should be populated as None
+            to specify that the revision 0 did not exist and the data should be added as revision 1
+        It needs to store the revision index that is current within the editor.
+        It also needs to store the revision that is saved to disk so that we know what has changed compared to
+            the current save state rather than the original save state.
+        If the above two indexes do not match then the data has been changed compared to the saved version so it needs saving.
+    global storage
+        We need to store a list of pools of keys that have changed for each undo point.
+        We also need to store the index of which pool is current. This will get changed when undoing/redoing to keep track.
+
+
+    When the creation of an undo point is requested
+        we should scan all of the objects and see if the `changed` flag has been set to `True`.
+        If this is the case the data has been changed and we should create a backup of it.
+            make sure to reset the `changed` flag to False for the cached version
+        A new revision for each entry is created and the current revision index is incremented.
+        A pool of keys that have changed should be created.
+            When undoing this change we look at this pool to see what changed and undo each of those.
+            The same applies when redoing
+        Finally the `changed` flags for each of the entries should be changed to False so that the next
+            undo point only catches what has changed since this undo point.
+            The better solution here is to empty the temporary database and re-populate from the latest cache
+                revision where the `changed` flag was already set to False. This also solves the issue where
+                the data was modified but the `changed` flag was not set to True by the script.
+
+global history manager
+    would store each of the local history managers
+    would be the entry
+"""
+
+from .changeable import Changeable

amulet/api/history/base/__init__.py

@@ -1,3 +1,3 @@
-from .base_history import BaseHistory
-from .revision_manager import RevisionManager
-from .history_manager import HistoryManager
+from .base_history import BaseHistory
+from .revision_manager import RevisionManager
+from .history_manager import HistoryManager

amulet/api/history/base/base_history.py

@@ -1,26 +1,26 @@
-from abc import ABC, abstractmethod
-
-
-class BaseHistory(ABC):
-    """The base class for all history related objects"""
-
-    @abstractmethod
-    def undo(self):
-        """Revert to the previous state."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def redo(self):
-        """Un-revert to the next state."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def mark_saved(self):
-        """Let the class know that the current state has been saved."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def changed(self) -> bool:
-        """Have there been modifications since the last save."""
-        raise NotImplementedError
+from abc import ABC, abstractmethod
+
+
+class BaseHistory(ABC):
+    """The base class for all history related objects"""
+
+    @abstractmethod
+    def undo(self):
+        """Revert to the previous state."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def redo(self):
+        """Un-revert to the next state."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def mark_saved(self):
+        """Let the class know that the current state has been saved."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def changed(self) -> bool:
+        """Have there been modifications since the last save."""
+        raise NotImplementedError