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

amulet/api/history/base/history_manager.py

@@ -1,63 +1,63 @@
-from abc import abstractmethod
-from typing import Generator
-
-from amulet.utils.generator import generator_unpacker
-
-from .base_history import BaseHistory
-
-
-class HistoryManager(BaseHistory):
-    """The base class for all active history manager objects.
-    The HistoryManager tracks which objects have changed but is not aware of how they have changed.
-    """
-
-    def create_undo_point(self) -> bool:
-        """
-        Find what has changed since the last undo point and optionally create a new undo point.
-
-        :return: Was an undo point created. If there were no changes no snapshot will be created.
-        """
-        return generator_unpacker(self.create_undo_point_iter())
-
-    @abstractmethod
-    def create_undo_point_iter(self) -> Generator[float, None, bool]:
-        """
-        Find what has changed since the last undo point and optionally create a new undo point.
-
-        :return: Was an undo point created. If there were no changes no snapshot will be created.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def restore_last_undo_point(self):
-        """
-        Restore the world to the state it was when self.create_undo_point was called.
-
-        If an operation errors there may be modifications made that did not get tracked.
-
-        This will revert those changes.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def purge(self):
-        """Unload all cached data. Effectively returns the class to its starting state."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def undo_count(self) -> int:
-        """The number of times the :meth:`undo` method can be run."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def redo_count(self) -> int:
-        """The number of times the :meth:`redo` method can be run."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def unsaved_changes(self) -> int:
-        """The number of changes that have been made since the last save"""
-        raise NotImplementedError
+from abc import abstractmethod
+from typing import Generator
+
+from amulet.utils.generator import generator_unpacker
+
+from .base_history import BaseHistory
+
+
+class HistoryManager(BaseHistory):
+    """The base class for all active history manager objects.
+    The HistoryManager tracks which objects have changed but is not aware of how they have changed.
+    """
+
+    def create_undo_point(self) -> bool:
+        """
+        Find what has changed since the last undo point and optionally create a new undo point.
+
+        :return: Was an undo point created. If there were no changes no snapshot will be created.
+        """
+        return generator_unpacker(self.create_undo_point_iter())
+
+    @abstractmethod
+    def create_undo_point_iter(self) -> Generator[float, None, bool]:
+        """
+        Find what has changed since the last undo point and optionally create a new undo point.
+
+        :return: Was an undo point created. If there were no changes no snapshot will be created.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def restore_last_undo_point(self):
+        """
+        Restore the world to the state it was when self.create_undo_point was called.
+
+        If an operation errors there may be modifications made that did not get tracked.
+
+        This will revert those changes.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def purge(self):
+        """Unload all cached data. Effectively returns the class to its starting state."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def undo_count(self) -> int:
+        """The number of times the :meth:`undo` method can be run."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def redo_count(self) -> int:
+        """The number of times the :meth:`redo` method can be run."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def unsaved_changes(self) -> int:
+        """The number of changes that have been made since the last save"""
+        raise NotImplementedError

amulet/api/history/base/revision_manager.py

@@ -1,73 +1,73 @@
-from abc import abstractmethod
-from typing import List, Optional, Any
-
-from .base_history import BaseHistory
-
-StoredEntryType = Optional[Any]
-
-
-class RevisionManager(BaseHistory):
-    """The base API for all passive history manager objects.
-    The RevisionManager stores the actual versions of the object to revert to."""
-
-    __slots__ = ("_revisions", "_current_revision_index", "_saved_revision_index")
-
-    def __init__(self, initial_state: StoredEntryType):
-        self._revisions: List[StoredEntryType] = []  # the data for each revision
-        self._current_revision_index: int = (
-            0  # the index into the above for the current data
-        )
-        self._saved_revision_index: int = (
-            0  # the index into the above for the saved version
-        )
-        self._store_entry(initial_state)
-
-    @property
-    def changed(self) -> bool:
-        """Have there been modifications since the last save."""
-        return self._current_revision_index != self._saved_revision_index
-
-    def put_new_entry(self, entry: StoredEntryType):
-        """Add a new entry to the database and increment the index."""
-        if len(self._revisions) > self._current_revision_index + 1:
-            # if there are upstream revisions delete them
-            del self._revisions[self._current_revision_index + 1 :]
-        if self._saved_revision_index > self._current_revision_index:
-            # we are starting a new branch and the save was on the old branch.
-            self._saved_revision_index = -1
-        self._store_entry(entry)
-        self._current_revision_index += 1
-
-    @abstractmethod
-    def _store_entry(self, entry: StoredEntryType):
-        """Store the entry data as required."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_current_entry(self):
-        """Get the entry at the current revision."""
-        raise NotImplementedError
-
-    def undo(self):
-        """Decrement the state of the entry to the previous revision."""
-        if self._current_revision_index <= 0:
-            raise Exception(
-                "Cannot undo past revision 0"
-            )  # if run there is a bug in the code
-        self._current_revision_index -= 1
-
-    def redo(self):
-        """Increment the state of the entry to the next revision."""
-        if self._current_revision_index >= len(self._revisions):
-            raise Exception(
-                "Cannot redo past the highest revision"
-            )  # if run there is a bug in the code
-        self._current_revision_index += 1
-
-    def mark_saved(self):
-        """Let the class know that the current state has been saved."""
-        self._saved_revision_index = self._current_revision_index
-
-    @property
-    def is_deleted(self) -> bool:
-        return self._revisions[self._current_revision_index] is None
+from abc import abstractmethod
+from typing import List, Optional, Any
+
+from .base_history import BaseHistory
+
+StoredEntryType = Optional[Any]
+
+
+class RevisionManager(BaseHistory):
+    """The base API for all passive history manager objects.
+    The RevisionManager stores the actual versions of the object to revert to."""
+
+    __slots__ = ("_revisions", "_current_revision_index", "_saved_revision_index")
+
+    def __init__(self, initial_state: StoredEntryType):
+        self._revisions: List[StoredEntryType] = []  # the data for each revision
+        self._current_revision_index: int = (
+            0  # the index into the above for the current data
+        )
+        self._saved_revision_index: int = (
+            0  # the index into the above for the saved version
+        )
+        self._store_entry(initial_state)
+
+    @property
+    def changed(self) -> bool:
+        """Have there been modifications since the last save."""
+        return self._current_revision_index != self._saved_revision_index
+
+    def put_new_entry(self, entry: StoredEntryType):
+        """Add a new entry to the database and increment the index."""
+        if len(self._revisions) > self._current_revision_index + 1:
+            # if there are upstream revisions delete them
+            del self._revisions[self._current_revision_index + 1 :]
+        if self._saved_revision_index > self._current_revision_index:
+            # we are starting a new branch and the save was on the old branch.
+            self._saved_revision_index = -1
+        self._store_entry(entry)
+        self._current_revision_index += 1
+
+    @abstractmethod
+    def _store_entry(self, entry: StoredEntryType):
+        """Store the entry data as required."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_current_entry(self):
+        """Get the entry at the current revision."""
+        raise NotImplementedError
+
+    def undo(self):
+        """Decrement the state of the entry to the previous revision."""
+        if self._current_revision_index <= 0:
+            raise Exception(
+                "Cannot undo past revision 0"
+            )  # if run there is a bug in the code
+        self._current_revision_index -= 1
+
+    def redo(self):
+        """Increment the state of the entry to the next revision."""
+        if self._current_revision_index >= len(self._revisions):
+            raise Exception(
+                "Cannot redo past the highest revision"
+            )  # if run there is a bug in the code
+        self._current_revision_index += 1
+
+    def mark_saved(self):
+        """Let the class know that the current state has been saved."""
+        self._saved_revision_index = self._current_revision_index
+
+    @property
+    def is_deleted(self) -> bool:
+        return self._revisions[self._current_revision_index] is None

amulet/api/history/changeable.py

@@ -1,15 +1,15 @@
-class Changeable:
-    """A class to track if an object has been changed."""
-
-    def __init__(self):
-        self._changed = False
-
-    @property
-    def changed(self) -> bool:
-        """Has the object been modified since the last revision."""
-        return self._changed
-
-    @changed.setter
-    def changed(self, changed: bool):
-        assert isinstance(changed, bool), "Changed must be a bool"
-        self._changed = changed
+class Changeable:
+    """A class to track if an object has been changed."""
+
+    def __init__(self):
+        self._changed = False
+
+    @property
+    def changed(self) -> bool:
+        """Has the object been modified since the last revision."""
+        return self._changed
+
+    @changed.setter
+    def changed(self, changed: bool):
+        assert isinstance(changed, bool), "Changed must be a bool"
+        self._changed = changed

amulet/api/history/data_types.py

@@ -1,7 +1,7 @@
-from typing import Optional, Any
-from .changeable import Changeable
-
-EntryKeyType = Any  # The key an entry is stored under
-EntryType = Optional[
-    Changeable
-]  # None is reserved for if the entry was deleted/did not exist
+from typing import Optional, Any
+from .changeable import Changeable
+
+EntryKeyType = Any  # The key an entry is stored under
+EntryType = Optional[
+    Changeable
+]  # None is reserved for if the entry was deleted/did not exist

amulet/api/history/history_manager/__init__.py

@@ -1,3 +1,3 @@
-from .object import ObjectHistoryManager
-from .database import DatabaseHistoryManager
-from .meta import MetaHistoryManager
+from .object import ObjectHistoryManager
+from .database import DatabaseHistoryManager
+from .meta import MetaHistoryManager

amulet/api/history/history_manager/container.py

@@ -1,102 +1,102 @@
-from abc import abstractmethod
-from typing import List, Any
-
-from amulet.api.history.base.history_manager import HistoryManager
-
-SnapshotType = Any
-
-
-class ContainerHistoryManager(HistoryManager):
-    def __init__(self):
-        self._snapshots: List[SnapshotType] = []
-        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
-
-    @abstractmethod
-    def _check_snapshot(self, snapshot: SnapshotType):
-        raise NotImplementedError
-
-    def _register_snapshot(self, snapshot: SnapshotType) -> bool:
-        """Create a snapshot if it contains data.
-
-        :param snapshot: The snapshot data to save.
-        :return: True if the snapshot was created, false otherwise.
-        """
-        self._check_snapshot(snapshot)
-        if snapshot:
-            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
-            # delete all upstream snapshots
-            del self._snapshots[self._snapshot_index :]
-            self._snapshots.append(snapshot)
-            return True
-        return False
-
-    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._mark_saved()
-
-    @abstractmethod
-    def _mark_saved(self):
-        raise NotImplementedError
-
-    @property
-    def undo_count(self) -> int:
-        return self._snapshot_index + 1
-
-    @property
-    def redo_count(self) -> int:
-        return len(self._snapshots) - (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 database"""
-        if self.undo_count > 0:
-            snapshot = self._snapshots[self._snapshot_index]
-            self._undo(snapshot)
-            self._snapshot_index -= 1
-
-    @abstractmethod
-    def _undo(self, snapshot: SnapshotType):
-        raise NotImplementedError
-
-    def redo(self):
-        """Redoes the last set of changes to the database"""
-        if self.redo_count > 0:
-            self._snapshot_index += 1
-            snapshot = self._snapshots[self._snapshot_index]
-            self._redo(snapshot)
-
-    @abstractmethod
-    def _redo(self, snapshot: SnapshotType):
-        raise NotImplementedError
-
-    @property
-    def changed(self) -> bool:
-        return bool(self.unsaved_changes)
-
-    def purge(self):
-        """Unload all cached data. Effectively returns the class to its starting state."""
-        self._snapshots.clear()
-        self._snapshot_index: int = -1
-        self._last_save_snapshot = -1
-        self._branch_save_count = 0
+from abc import abstractmethod
+from typing import List, Any
+
+from amulet.api.history.base.history_manager import HistoryManager
+
+SnapshotType = Any
+
+
+class ContainerHistoryManager(HistoryManager):
+    def __init__(self):
+        self._snapshots: List[SnapshotType] = []
+        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
+
+    @abstractmethod
+    def _check_snapshot(self, snapshot: SnapshotType):
+        raise NotImplementedError
+
+    def _register_snapshot(self, snapshot: SnapshotType) -> bool:
+        """Create a snapshot if it contains data.
+
+        :param snapshot: The snapshot data to save.
+        :return: True if the snapshot was created, false otherwise.
+        """
+        self._check_snapshot(snapshot)
+        if snapshot:
+            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
+            # delete all upstream snapshots
+            del self._snapshots[self._snapshot_index :]
+            self._snapshots.append(snapshot)
+            return True
+        return False
+
+    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._mark_saved()
+
+    @abstractmethod
+    def _mark_saved(self):
+        raise NotImplementedError
+
+    @property
+    def undo_count(self) -> int:
+        return self._snapshot_index + 1
+
+    @property
+    def redo_count(self) -> int:
+        return len(self._snapshots) - (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 database"""
+        if self.undo_count > 0:
+            snapshot = self._snapshots[self._snapshot_index]
+            self._undo(snapshot)
+            self._snapshot_index -= 1
+
+    @abstractmethod
+    def _undo(self, snapshot: SnapshotType):
+        raise NotImplementedError
+
+    def redo(self):
+        """Redoes the last set of changes to the database"""
+        if self.redo_count > 0:
+            self._snapshot_index += 1
+            snapshot = self._snapshots[self._snapshot_index]
+            self._redo(snapshot)
+
+    @abstractmethod
+    def _redo(self, snapshot: SnapshotType):
+        raise NotImplementedError
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.unsaved_changes)
+
+    def purge(self):
+        """Unload all cached data. Effectively returns the class to its starting state."""
+        self._snapshots.clear()
+        self._snapshot_index: int = -1
+        self._last_save_snapshot = -1
+        self._branch_save_count = 0