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

amulet/api/history/history_manager/meta.py

@@ -1,93 +1,93 @@
-from typing import Tuple, Generator
-
-from amulet.utils.generator import generator_unpacker
-from amulet.api.history.base.history_manager import HistoryManager
-from .container import ContainerHistoryManager
-
-SnapshotType = Tuple[HistoryManager, ...]
-
-
-class MetaHistoryManager(ContainerHistoryManager):
-    def __init__(self):
-        super().__init__()
-        self._world_managers = []
-        self._non_world_managers = []
-
-    def _check_snapshot(self, snapshot: SnapshotType):
-        assert isinstance(snapshot, tuple) and all(
-            isinstance(item, HistoryManager) for item in snapshot
-        )
-
-    def register(self, manager: HistoryManager, is_world_manager: bool):
-        """
-        Register a manager to track.
-        :param manager: The manager to track
-        :param is_world_manager: Is the manager tracking world data
-        :return:
-        """
-        assert isinstance(
-            manager, HistoryManager
-        ), "manager must be an instance of BaseHistoryManager"
-        if is_world_manager:
-            self._world_managers.append(manager)
-        else:
-            self._non_world_managers.append(manager)
-
-    def _undo(self, snapshot: SnapshotType):
-        for item in snapshot:
-            item.undo()
-
-    def _redo(self, snapshot: SnapshotType):
-        for item in snapshot:
-            item.redo()
-
-    def _mark_saved(self):
-        for manager in self._managers():
-            manager.mark_saved()
-
-    def _managers(
-        self, world: bool = True, non_world: bool = True
-    ) -> Tuple[HistoryManager, ...]:
-        return (
-            tuple(self._world_managers) * world
-            + tuple(self._non_world_managers) * non_world
-        )
-
-    @property
-    def changed(self) -> bool:
-        if super().changed:
-            return True
-        managers = self._managers(True, False)
-        for manager in managers:
-            if manager.changed:
-                return True
-        return False
-
-    def create_undo_point(self, world=True, non_world=True) -> bool:
-        return generator_unpacker(self.create_undo_point_iter(world, non_world))
-
-    def create_undo_point_iter(
-        self, world=True, non_world=True
-    ) -> Generator[float, None, bool]:
-        """Create an undo point.
-
-        :param world: Should the world based history managers be included
-        :param non_world: Should the non-world based history managers be included
-        :return:
-        """
-        managers = self._managers(world, non_world)
-        snapshot = []
-        for manager in managers:
-            changed = yield from manager.create_undo_point_iter()
-            if changed:
-                snapshot.append(manager)
-        return self._register_snapshot(tuple(snapshot))
-
-    def restore_last_undo_point(self):
-        for manager in self._managers():
-            manager.restore_last_undo_point()
-
-    def purge(self):
-        """Unload all history data. Restore to the state after creation."""
-        for manager in self._managers():
-            manager.purge()
+from typing import Tuple, Generator
+
+from amulet.utils.generator import generator_unpacker
+from amulet.api.history.base.history_manager import HistoryManager
+from .container import ContainerHistoryManager
+
+SnapshotType = Tuple[HistoryManager, ...]
+
+
+class MetaHistoryManager(ContainerHistoryManager):
+    def __init__(self):
+        super().__init__()
+        self._world_managers = []
+        self._non_world_managers = []
+
+    def _check_snapshot(self, snapshot: SnapshotType):
+        assert isinstance(snapshot, tuple) and all(
+            isinstance(item, HistoryManager) for item in snapshot
+        )
+
+    def register(self, manager: HistoryManager, is_world_manager: bool):
+        """
+        Register a manager to track.
+        :param manager: The manager to track
+        :param is_world_manager: Is the manager tracking world data
+        :return:
+        """
+        assert isinstance(
+            manager, HistoryManager
+        ), "manager must be an instance of BaseHistoryManager"
+        if is_world_manager:
+            self._world_managers.append(manager)
+        else:
+            self._non_world_managers.append(manager)
+
+    def _undo(self, snapshot: SnapshotType):
+        for item in snapshot:
+            item.undo()
+
+    def _redo(self, snapshot: SnapshotType):
+        for item in snapshot:
+            item.redo()
+
+    def _mark_saved(self):
+        for manager in self._managers():
+            manager.mark_saved()
+
+    def _managers(
+        self, world: bool = True, non_world: bool = True
+    ) -> Tuple[HistoryManager, ...]:
+        return (
+            tuple(self._world_managers) * world
+            + tuple(self._non_world_managers) * non_world
+        )
+
+    @property
+    def changed(self) -> bool:
+        if super().changed:
+            return True
+        managers = self._managers(True, False)
+        for manager in managers:
+            if manager.changed:
+                return True
+        return False
+
+    def create_undo_point(self, world=True, non_world=True) -> bool:
+        return generator_unpacker(self.create_undo_point_iter(world, non_world))
+
+    def create_undo_point_iter(
+        self, world=True, non_world=True
+    ) -> Generator[float, None, bool]:
+        """Create an undo point.
+
+        :param world: Should the world based history managers be included
+        :param non_world: Should the non-world based history managers be included
+        :return:
+        """
+        managers = self._managers(world, non_world)
+        snapshot = []
+        for manager in managers:
+            changed = yield from manager.create_undo_point_iter()
+            if changed:
+                snapshot.append(manager)
+        return self._register_snapshot(tuple(snapshot))
+
+    def restore_last_undo_point(self):
+        for manager in self._managers():
+            manager.restore_last_undo_point()
+
+    def purge(self):
+        """Unload all history data. Restore to the state after creation."""
+        for manager in self._managers():
+            manager.purge()

amulet/api/history/history_manager/object.py

@@ -1,116 +1,116 @@
-from typing import Optional, Any, Generator
-
-from amulet.api.history import Changeable
-from ..base import RevisionManager
-from amulet.api.history.base.history_manager import HistoryManager
-from ..revision_manager import RAMRevisionManager
-
-
-class ObjectHistoryManager(HistoryManager):
-    def __init__(self, original_entry: Changeable):
-        super().__init__()
-        self._value: Changeable = original_entry
-        self._revision_manager = self._create_new_revision_manager(
-            self._pack_value(self._value)
-        )
-        self._snapshots_size: int = 0
-        self._snapshot_index: int = -1
-
-        # the snapshot that was saved or the save branches off from
-        self._last_save_snapshot = -1
-        self._branch_save_count = 0  # if the user saves, undoes and does a new operation a save branch will be lost
-        # This is the number of changes on that branch
-
-    @property
-    def value(self):
-        return self._value
-
-    @staticmethod
-    def _create_new_revision_manager(original_entry: Optional[Any]) -> RevisionManager:
-        """Create an RevisionManager as desired and populate it with the original entry."""
-        return RAMRevisionManager(original_entry)
-
-    def _register_snapshot(self):
-        if self._last_save_snapshot > self._snapshot_index:
-            # if the user has undone changes and made more changes things get a bit messy
-            # This fixes the property storing the number of changes since the last save.
-            self._branch_save_count += self._last_save_snapshot - self._snapshot_index
-            self._last_save_snapshot = self._snapshot_index
-        self._snapshot_index += 1
-        self._snapshots_size = min(self._snapshots_size, self._snapshot_index) + 1
-
-    def mark_saved(self):
-        """Let the class know that the current state has been saved."""
-        self._last_save_snapshot = self._snapshot_index
-        self._branch_save_count = 0
-        self._revision_manager.mark_saved()
-
-    def purge(self):
-        """Unload the cached objects and restore to the starting value."""
-        self._revision_manager = self._create_new_revision_manager(
-            self._pack_value(self._value)
-        )
-        self._snapshots_size: int = 0
-        self._snapshot_index: int = -1
-        self._last_save_snapshot = -1
-        self._branch_save_count = 0
-
-    @property
-    def undo_count(self) -> int:
-        return self._snapshot_index + 1
-
-    @property
-    def redo_count(self) -> int:
-        return self._snapshots_size - (self._snapshot_index + 1)
-
-    @property
-    def unsaved_changes(self) -> int:
-        """The number of changes that have been made since the last save"""
-        return (
-            abs(self._snapshot_index - self._last_save_snapshot)
-            + self._branch_save_count
-        )
-
-    def undo(self):
-        """Undoes the last set of changes to the object"""
-        if self.undo_count > 0:
-            self._revision_manager.undo()
-            self._unpack()
-            self._snapshot_index -= 1
-
-    def redo(self):
-        """Redoes the last set of changes to the object"""
-        if self.redo_count > 0:
-            self._snapshot_index += 1
-            self._revision_manager.redo()
-            self._unpack()
-
-    @property
-    def changed(self) -> bool:
-        return bool(self.unsaved_changes)
-
-    def create_undo_point_iter(self) -> Generator[float, None, bool]:
-        yield 1
-        if self._value.changed:
-            self._value.changed = False
-            self._pack()
-            self._register_snapshot()
-            return True
-        else:
-            self._unpack()
-            return False
-
-    def restore_last_undo_point(self):
-        self._unpack()
-
-    def _unpack(self):
-        self._unpack_value(self._revision_manager.get_current_entry())
-
-    def _unpack_value(self, value: Optional[Any]):
-        self._value = value
-
-    def _pack(self):
-        self._revision_manager.put_new_entry(self._pack_value(self._value))
-
-    def _pack_value(self, value: Optional[Any]) -> Optional[Any]:
-        return value
+from typing import Optional, Any, Generator
+
+from amulet.api.history import Changeable
+from ..base import RevisionManager
+from amulet.api.history.base.history_manager import HistoryManager
+from ..revision_manager import RAMRevisionManager
+
+
+class ObjectHistoryManager(HistoryManager):
+    def __init__(self, original_entry: Changeable):
+        super().__init__()
+        self._value: Changeable = original_entry
+        self._revision_manager = self._create_new_revision_manager(
+            self._pack_value(self._value)
+        )
+        self._snapshots_size: int = 0
+        self._snapshot_index: int = -1
+
+        # the snapshot that was saved or the save branches off from
+        self._last_save_snapshot = -1
+        self._branch_save_count = 0  # if the user saves, undoes and does a new operation a save branch will be lost
+        # This is the number of changes on that branch
+
+    @property
+    def value(self):
+        return self._value
+
+    @staticmethod
+    def _create_new_revision_manager(original_entry: Optional[Any]) -> RevisionManager:
+        """Create an RevisionManager as desired and populate it with the original entry."""
+        return RAMRevisionManager(original_entry)
+
+    def _register_snapshot(self):
+        if self._last_save_snapshot > self._snapshot_index:
+            # if the user has undone changes and made more changes things get a bit messy
+            # This fixes the property storing the number of changes since the last save.
+            self._branch_save_count += self._last_save_snapshot - self._snapshot_index
+            self._last_save_snapshot = self._snapshot_index
+        self._snapshot_index += 1
+        self._snapshots_size = min(self._snapshots_size, self._snapshot_index) + 1
+
+    def mark_saved(self):
+        """Let the class know that the current state has been saved."""
+        self._last_save_snapshot = self._snapshot_index
+        self._branch_save_count = 0
+        self._revision_manager.mark_saved()
+
+    def purge(self):
+        """Unload the cached objects and restore to the starting value."""
+        self._revision_manager = self._create_new_revision_manager(
+            self._pack_value(self._value)
+        )
+        self._snapshots_size: int = 0
+        self._snapshot_index: int = -1
+        self._last_save_snapshot = -1
+        self._branch_save_count = 0
+
+    @property
+    def undo_count(self) -> int:
+        return self._snapshot_index + 1
+
+    @property
+    def redo_count(self) -> int:
+        return self._snapshots_size - (self._snapshot_index + 1)
+
+    @property
+    def unsaved_changes(self) -> int:
+        """The number of changes that have been made since the last save"""
+        return (
+            abs(self._snapshot_index - self._last_save_snapshot)
+            + self._branch_save_count
+        )
+
+    def undo(self):
+        """Undoes the last set of changes to the object"""
+        if self.undo_count > 0:
+            self._revision_manager.undo()
+            self._unpack()
+            self._snapshot_index -= 1
+
+    def redo(self):
+        """Redoes the last set of changes to the object"""
+        if self.redo_count > 0:
+            self._snapshot_index += 1
+            self._revision_manager.redo()
+            self._unpack()
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.unsaved_changes)
+
+    def create_undo_point_iter(self) -> Generator[float, None, bool]:
+        yield 1
+        if self._value.changed:
+            self._value.changed = False
+            self._pack()
+            self._register_snapshot()
+            return True
+        else:
+            self._unpack()
+            return False
+
+    def restore_last_undo_point(self):
+        self._unpack()
+
+    def _unpack(self):
+        self._unpack_value(self._revision_manager.get_current_entry())
+
+    def _unpack_value(self, value: Optional[Any]):
+        self._value = value
+
+    def _pack(self):
+        self._revision_manager.put_new_entry(self._pack_value(self._value))
+
+    def _pack_value(self, value: Optional[Any]) -> Optional[Any]:
+        return value

amulet/api/history/revision_manager/__init__.py

@@ -1,2 +1,2 @@
-from .ram import RAMRevisionManager
-from .disk import DBRevisionManager
+from .ram import RAMRevisionManager
+from .disk import DBRevisionManager

amulet/api/history/revision_manager/disk.py

@@ -1,33 +1,33 @@
-from abc import abstractmethod
-from typing import Optional
-
-from amulet.api.history.base import RevisionManager
-from ..data_types import EntryType
-
-
-class DBRevisionManager(RevisionManager):
-    """A class to hold data about an entries history on disk.
-    Revision indexes are still stored in RAM."""
-
-    __slots__ = ("_prefix",)
-
-    def __init__(self, prefix: str, initial_state: EntryType):
-        self._prefix: str = prefix
-        super().__init__(initial_state)
-
-    def _store_entry(self, entry: EntryType):
-        path = f"{self._prefix}/{len(self._revisions)}"
-        path = self._serialise(path, entry)
-        self._revisions.append(path)
-
-    @abstractmethod
-    def _serialise(self, path: str, entry: EntryType) -> Optional[str]:
-        raise NotImplementedError
-
-    def get_current_entry(self):
-        path = self._revisions[self._current_revision_index]
-        return self._deserialise(path)
-
-    @abstractmethod
-    def _deserialise(self, path: str) -> EntryType:
-        raise NotImplementedError
+from abc import abstractmethod
+from typing import Optional
+
+from amulet.api.history.base import RevisionManager
+from ..data_types import EntryType
+
+
+class DBRevisionManager(RevisionManager):
+    """A class to hold data about an entries history on disk.
+    Revision indexes are still stored in RAM."""
+
+    __slots__ = ("_prefix",)
+
+    def __init__(self, prefix: str, initial_state: EntryType):
+        self._prefix: str = prefix
+        super().__init__(initial_state)
+
+    def _store_entry(self, entry: EntryType):
+        path = f"{self._prefix}/{len(self._revisions)}"
+        path = self._serialise(path, entry)
+        self._revisions.append(path)
+
+    @abstractmethod
+    def _serialise(self, path: str, entry: EntryType) -> Optional[str]:
+        raise NotImplementedError
+
+    def get_current_entry(self):
+        path = self._revisions[self._current_revision_index]
+        return self._deserialise(path)
+
+    @abstractmethod
+    def _deserialise(self, path: str) -> EntryType:
+        raise NotImplementedError

amulet/api/history/revision_manager/ram.py

@@ -1,12 +1,12 @@
-from amulet.api.history.base import RevisionManager
-from ..data_types import EntryType
-
-
-class RAMRevisionManager(RevisionManager):
-    """A class to hold data about an entries history in RAM."""
-
-    def _store_entry(self, entry: EntryType):
-        self._revisions.append(entry)
-
-    def get_current_entry(self):
-        return self._revisions[self._current_revision_index]
+from amulet.api.history.base import RevisionManager
+from ..data_types import EntryType
+
+
+class RAMRevisionManager(RevisionManager):
+    """A class to hold data about an entries history in RAM."""
+
+    def _store_entry(self, entry: EntryType):
+        self._revisions.append(entry)
+
+    def get_current_entry(self):
+        return self._revisions[self._current_revision_index]

amulet/api/item.py

@@ -1,75 +1,75 @@
-from amulet_nbt import CompoundTag, StringTag
-
-
-class Item(CompoundTag):
-    """
-    {
-        "namespace": StringTag,
-        "base_name": StringTag,
-        "metadata": CompoundTag
-    }
-    """
-
-    def __init__(self, namespace: str, base_name: str, metadata: dict = None):
-        super().__init__(
-            {
-                "namespace": StringTag(namespace),
-                "base_name": StringTag(base_name),
-                "metadata": CompoundTag(metadata or {}),
-            }
-        )
-
-    @property
-    def namespace(self) -> str:
-        return self.get_string("namespace").py_str
-
-    @property
-    def base_name(self) -> str:
-        return self.get_string("base_name").py_str
-
-    @property
-    def metadata(self) -> CompoundTag:
-        return self.get_compound("metadata")
-
-
-class BlockItem(CompoundTag):
-    """
-    {
-        "namespace": StringTag,
-        "base_name": StringTag,
-        "properties": CompoundTag
-        "metadata": CompoundTag
-    }
-    """
-
-    def __init__(
-        self,
-        namespace: str,
-        base_name: str,
-        properties: dict = None,
-        metadata: dict = None,
-    ):
-        super().__init__(
-            {
-                "namespace": StringTag(namespace),
-                "base_name": StringTag(base_name),
-                "properties": CompoundTag(properties or {}),
-                "metadata": CompoundTag(metadata or {}),
-            }
-        )
-
-    @property
-    def namespace(self) -> str:
-        return self.get_string("namespace").py_str
-
-    @property
-    def base_name(self) -> str:
-        return self.get_string("base_name").py_str
-
-    @property
-    def properties(self) -> CompoundTag:
-        return self.get_compound("properties")
-
-    @property
-    def metadata(self) -> CompoundTag:
-        return self.get_compound("metadata")
+from amulet_nbt import CompoundTag, StringTag
+
+
+class Item(CompoundTag):
+    """
+    {
+        "namespace": StringTag,
+        "base_name": StringTag,
+        "metadata": CompoundTag
+    }
+    """
+
+    def __init__(self, namespace: str, base_name: str, metadata: dict = None):
+        super().__init__(
+            {
+                "namespace": StringTag(namespace),
+                "base_name": StringTag(base_name),
+                "metadata": CompoundTag(metadata or {}),
+            }
+        )
+
+    @property
+    def namespace(self) -> str:
+        return self.get_string("namespace").py_str
+
+    @property
+    def base_name(self) -> str:
+        return self.get_string("base_name").py_str
+
+    @property
+    def metadata(self) -> CompoundTag:
+        return self.get_compound("metadata")
+
+
+class BlockItem(CompoundTag):
+    """
+    {
+        "namespace": StringTag,
+        "base_name": StringTag,
+        "properties": CompoundTag
+        "metadata": CompoundTag
+    }
+    """
+
+    def __init__(
+        self,
+        namespace: str,
+        base_name: str,
+        properties: dict = None,
+        metadata: dict = None,
+    ):
+        super().__init__(
+            {
+                "namespace": StringTag(namespace),
+                "base_name": StringTag(base_name),
+                "properties": CompoundTag(properties or {}),
+                "metadata": CompoundTag(metadata or {}),
+            }
+        )
+
+    @property
+    def namespace(self) -> str:
+        return self.get_string("namespace").py_str
+
+    @property
+    def base_name(self) -> str:
+        return self.get_string("base_name").py_str
+
+    @property
+    def properties(self) -> CompoundTag:
+        return self.get_compound("properties")
+
+    @property
+    def metadata(self) -> CompoundTag:
+        return self.get_compound("metadata")