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

amulet/api/level/base_level/player_manager.py

@@ -1,101 +1,101 @@
-from __future__ import annotations
-
-from typing import Generator, Set, Iterable, Dict
-
-import weakref
-
-from amulet.api.player import Player
-from amulet.api.history.history_manager import DatabaseHistoryManager
-from amulet.api.history.revision_manager import RAMRevisionManager
-from amulet.api import level as api_level
-from amulet.api.errors import PlayerLoadError, PlayerDoesNotExist
-
-
-class PlayerManager(DatabaseHistoryManager):
-    _temporary_database: Dict[str, Player]
-    _history_database: Dict[str, RAMRevisionManager]
-
-    DoesNotExistError = PlayerDoesNotExist
-    LoadError = PlayerLoadError
-
-    def __init__(self, level: api_level.BaseLevel):
-        """
-        Construct a new :class:`PlayerManager` instance
-
-        This should not be used by third party code
-
-        :param level: The world that this player manager is associated with
-        """
-        super().__init__()
-        self._level = weakref.ref(level)
-
-    @property
-    def level(self) -> api_level.BaseLevel:
-        """The level that this player manager is associated with."""
-        return self._level()
-
-    def all_player_ids(self) -> Set[str]:
-        """
-        Returns a set of all player ids that are present in the level
-        """
-        return self._all_entries()
-
-    def _raw_all_entries(self) -> Iterable[str]:
-        return self.level.level_wrapper.all_player_ids()
-
-    def changed_players(self) -> Generator[str, None, None]:
-        """The player objects that have changed since the last save"""
-        return self.changed_entries()
-
-    def has_player(self, player_id: str) -> bool:
-        """
-        Is the given player id present in the level
-
-        :param player_id: The player id to check
-        :return: True if the player id is present, False otherwise
-        """
-        return self._has_entry(player_id)
-
-    def _raw_has_entry(self, key: str) -> bool:
-        return self.level.level_wrapper.has_player(key)
-
-    def __contains__(self, item):
-        """
-        Is the given player id present in the level
-
-        >>> '<uuid>' in level.players
-
-        :param item: The player id to check
-        :return: True if the player id is present, False otherwise
-        """
-        return self.has_player(item)
-
-    def put_player(self, player: Player):
-        """
-        Add the given player to the player manager.
-
-        :param player: The :class:`Player` object to add to the chunk manager. It will be added with the key designated by :attr:`Player.uuid`
-        """
-        self._put_entry(player.player_id, player)
-
-    def get_player(self, player_id: str) -> Player:
-        """
-        Gets the :class:`Player` object that belongs to the specified player id
-
-        If no parameter is supplied, the data of the local player will be returned
-
-        :param player_id: The desired player id
-        :return: A Player instance
-        """
-        return self._get_entry(player_id)
-
-    def _raw_get_entry(self, key: str) -> Player:
-        return self.level.level_wrapper.load_player(key)
-
-    def delete_player(self, player_id: str):
-        """
-        Deletes a player from the player manager
-
-        :param player_id: The desired player id
-        """
-        self._delete_entry(player_id)
+from __future__ import annotations
+
+from typing import Generator, Set, Iterable, Dict
+
+import weakref
+
+from amulet.api.player import Player
+from amulet.api.history.history_manager import DatabaseHistoryManager
+from amulet.api.history.revision_manager import RAMRevisionManager
+from amulet.api import level as api_level
+from amulet.api.errors import PlayerLoadError, PlayerDoesNotExist
+
+
+class PlayerManager(DatabaseHistoryManager):
+    _temporary_database: Dict[str, Player]
+    _history_database: Dict[str, RAMRevisionManager]
+
+    DoesNotExistError = PlayerDoesNotExist
+    LoadError = PlayerLoadError
+
+    def __init__(self, level: api_level.BaseLevel):
+        """
+        Construct a new :class:`PlayerManager` instance
+
+        This should not be used by third party code
+
+        :param level: The world that this player manager is associated with
+        """
+        super().__init__()
+        self._level = weakref.ref(level)
+
+    @property
+    def level(self) -> api_level.BaseLevel:
+        """The level that this player manager is associated with."""
+        return self._level()
+
+    def all_player_ids(self) -> Set[str]:
+        """
+        Returns a set of all player ids that are present in the level
+        """
+        return self._all_entries()
+
+    def _raw_all_entries(self) -> Iterable[str]:
+        return self.level.level_wrapper.all_player_ids()
+
+    def changed_players(self) -> Generator[str, None, None]:
+        """The player objects that have changed since the last save"""
+        return self.changed_entries()
+
+    def has_player(self, player_id: str) -> bool:
+        """
+        Is the given player id present in the level
+
+        :param player_id: The player id to check
+        :return: True if the player id is present, False otherwise
+        """
+        return self._has_entry(player_id)
+
+    def _raw_has_entry(self, key: str) -> bool:
+        return self.level.level_wrapper.has_player(key)
+
+    def __contains__(self, item):
+        """
+        Is the given player id present in the level
+
+        >>> '<uuid>' in level.players
+
+        :param item: The player id to check
+        :return: True if the player id is present, False otherwise
+        """
+        return self.has_player(item)
+
+    def put_player(self, player: Player):
+        """
+        Add the given player to the player manager.
+
+        :param player: The :class:`Player` object to add to the chunk manager. It will be added with the key designated by :attr:`Player.uuid`
+        """
+        self._put_entry(player.player_id, player)
+
+    def get_player(self, player_id: str) -> Player:
+        """
+        Gets the :class:`Player` object that belongs to the specified player id
+
+        If no parameter is supplied, the data of the local player will be returned
+
+        :param player_id: The desired player id
+        :return: A Player instance
+        """
+        return self._get_entry(player_id)
+
+    def _raw_get_entry(self, key: str) -> Player:
+        return self.level.level_wrapper.load_player(key)
+
+    def delete_player(self, player_id: str):
+        """
+        Deletes a player from the player manager
+
+        :param player_id: The desired player id
+        """
+        self._delete_entry(player_id)

amulet/api/level/immutable_structure/__init__.py

@@ -1 +1 @@
-from .immutable_structure import ImmutableStructure
+from .immutable_structure import ImmutableStructure

amulet/api/level/immutable_structure/immutable_structure.py

@@ -1,94 +1,94 @@
-from __future__ import annotations
-from typing import Generator
-
-from ..base_level import BaseLevel
-from .void_format_wrapper import VoidFormatWrapper
-from amulet.api.chunk import Chunk
-from amulet.api.data_types import Dimension
-from amulet.api.selection import SelectionGroup, SelectionBox
-from amulet.utils.generator import generator_unpacker
-import copy
-
-
-class ImmutableStructure(BaseLevel):
-    """
-    This is a special version of the level class that is only used when extracting a region of the world.
-
-    It is much the same as a normal level class but does not have an associated file/folder data like :class:`~amulet.api.level.World` and :class:`~amulet.api.level.Structure` do.
-
-    To extract a section of a world you should use :meth:`~amulet.api.level.BaseLevel.extract_structure`.
-    """
-
-    def __init__(
-        self,
-    ):
-        """
-        Construct an :class:`ImmutableStructure` instance.
-
-        You probably don't want to call this directly.
-
-        To extract a section of a world you should use :meth:`~amulet.api.level.BaseLevel.extract_structure`.
-        """
-        super().__init__("", VoidFormatWrapper(""))
-        self._selection = SelectionGroup(
-            [
-                SelectionBox(
-                    (-30_000_000, -30_000_000, -30_000_000),
-                    (30_000_000, 30_000_000, 30_000_000),
-                )
-            ]
-        )
-
-    @property
-    def selection_bounds(self) -> SelectionGroup:
-        return self._selection
-
-    def bounds(self, dimension: Dimension) -> SelectionGroup:
-        return self._selection
-
-    def undo(self):
-        pass
-
-    def redo(self):
-        pass
-
-    def put_chunk(self, chunk: Chunk, dimension: Dimension):
-        super().put_chunk(chunk, dimension)
-        self.history_manager.create_undo_point()
-
-    @classmethod
-    def from_level(
-        cls, level: BaseLevel, selection: SelectionGroup, dimension: Dimension
-    ):
-        """
-        Extract a section of the level into an :class:`ImmutableStructure` class.
-
-        :param level: The level to extract the area from.
-        :param selection: The selection to extract.
-        :param dimension: The dimension to extract from.
-        :return: The created instance of :class:`ImmutableStructure`
-        """
-        return generator_unpacker(cls.from_level_iter(level, selection, dimension))
-
-    @classmethod
-    def from_level_iter(
-        cls, level: BaseLevel, selection: SelectionGroup, dimension: Dimension
-    ) -> Generator[float, None, ImmutableStructure]:
-        """
-        Extract a section of the level into an :class:`ImmutableStructure` class.
-
-        Also yields the progress from 0-1.
-
-        :param level: The level to extract the area from.
-        :param selection: The selection to extract.
-        :param dimension: The dimension to extract from.
-        :return: The created instance of :class:`ImmutableStructure`
-        """
-        self = cls()
-        self._selection = selection
-        dst_dimension = self.dimensions[0]
-        count = len(list(level.get_coord_box(dimension, selection)))
-        for index, (chunk, _) in enumerate(level.get_chunk_boxes(dimension, selection)):
-            self.put_chunk(copy.deepcopy(chunk), dst_dimension)
-            yield (index + 1) / count
-        return self
+from __future__ import annotations
+from typing import Generator
+
+from ..base_level import BaseLevel
+from .void_format_wrapper import VoidFormatWrapper
+from amulet.api.chunk import Chunk
+from amulet.api.data_types import Dimension
+from amulet.api.selection import SelectionGroup, SelectionBox
+from amulet.utils.generator import generator_unpacker
+import copy
+
+
+class ImmutableStructure(BaseLevel):
+    """
+    This is a special version of the level class that is only used when extracting a region of the world.
+
+    It is much the same as a normal level class but does not have an associated file/folder data like :class:`~amulet.api.level.World` and :class:`~amulet.api.level.Structure` do.
+
+    To extract a section of a world you should use :meth:`~amulet.api.level.BaseLevel.extract_structure`.
+    """
+
+    def __init__(
+        self,
+    ):
+        """
+        Construct an :class:`ImmutableStructure` instance.
+
+        You probably don't want to call this directly.
+
+        To extract a section of a world you should use :meth:`~amulet.api.level.BaseLevel.extract_structure`.
+        """
+        super().__init__("", VoidFormatWrapper(""))
+        self._selection = SelectionGroup(
+            [
+                SelectionBox(
+                    (-30_000_000, -30_000_000, -30_000_000),
+                    (30_000_000, 30_000_000, 30_000_000),
+                )
+            ]
+        )
+
+    @property
+    def selection_bounds(self) -> SelectionGroup:
+        return self._selection
+
+    def bounds(self, dimension: Dimension) -> SelectionGroup:
+        return self._selection
+
+    def undo(self):
+        pass
+
+    def redo(self):
+        pass
+
+    def put_chunk(self, chunk: Chunk, dimension: Dimension):
+        super().put_chunk(chunk, dimension)
+        self.history_manager.create_undo_point()
+
+    @classmethod
+    def from_level(
+        cls, level: BaseLevel, selection: SelectionGroup, dimension: Dimension
+    ):
+        """
+        Extract a section of the level into an :class:`ImmutableStructure` class.
+
+        :param level: The level to extract the area from.
+        :param selection: The selection to extract.
+        :param dimension: The dimension to extract from.
+        :return: The created instance of :class:`ImmutableStructure`
+        """
+        return generator_unpacker(cls.from_level_iter(level, selection, dimension))
+
+    @classmethod
+    def from_level_iter(
+        cls, level: BaseLevel, selection: SelectionGroup, dimension: Dimension
+    ) -> Generator[float, None, ImmutableStructure]:
+        """
+        Extract a section of the level into an :class:`ImmutableStructure` class.
+
+        Also yields the progress from 0-1.
+
+        :param level: The level to extract the area from.
+        :param selection: The selection to extract.
+        :param dimension: The dimension to extract from.
+        :return: The created instance of :class:`ImmutableStructure`
+        """
+        self = cls()
+        self._selection = selection
+        dst_dimension = self.dimensions[0]
+        count = len(list(level.get_coord_box(dimension, selection)))
+        for index, (chunk, _) in enumerate(level.get_chunk_boxes(dimension, selection)):
+            self.put_chunk(copy.deepcopy(chunk), dst_dimension)
+            yield (index + 1) / count
+        return self

amulet/api/level/immutable_structure/void_format_wrapper.py

@@ -1,117 +1,117 @@
-from typing import Any, List, Dict, Tuple, Optional, TYPE_CHECKING, Iterable, Union
-
-from amulet.api.data_types import (
-    Dimension,
-    PlatformType,
-    ChunkCoordinates,
-    AnyNDArray,
-    VersionNumberTuple,
-)
-from amulet.api.wrapper import FormatWrapper
-from amulet.api.errors import ChunkDoesNotExist, PlayerDoesNotExist
-from amulet.api.player import Player
-from amulet.api.chunk import Chunk
-from amulet.api.selection import SelectionGroup
-from amulet.api import wrapper as api_wrapper
-
-if TYPE_CHECKING:
-    from amulet.api.wrapper import Interface
-
-
-class VoidFormatWrapper(FormatWrapper[VersionNumberTuple]):
-    """
-    A custom :class:`FormatWrapper` class that has no associated data.
-
-    This is just to make the :class:`ImmutableStructure` class happy since it requires a :class:`FormatWrapper` class.
-
-    All methods effectively do nothing.
-    """
-
-    def __init__(self, path: str):
-        super().__init__(path)
-        self._platform = "Unknown Platform"
-        self._version = (0, 0, 0)
-
-    @property
-    def level_name(self) -> str:
-        return "Void"
-
-    @staticmethod
-    def is_valid(path: str) -> bool:
-        return False
-
-    @property
-    def valid_formats(self) -> Dict[PlatformType, Tuple[bool, bool]]:
-        return {}
-
-    @property
-    def dimensions(self) -> List[Dimension]:
-        return ["main"]
-
-    @property
-    def can_add_dimension(self) -> bool:
-        return False
-
-    def register_dimension(self, dimension_identifier: Any):
-        pass
-
-    def _get_interface(self, raw_chunk_data: Optional[Any] = None) -> "Interface":
-        raise Exception("If this is called something is wrong")
-
-    def _encode(
-        self,
-        interface: api_wrapper.Interface,
-        chunk: Chunk,
-        dimension: Dimension,
-        chunk_palette: AnyNDArray,
-    ) -> Any:
-        raise Exception("If this is called something is wrong")
-
-    def _create(
-        self,
-        overwrite: bool,
-        bounds: Union[
-            SelectionGroup, Dict[Dimension, Optional[SelectionGroup]], None
-        ] = None,
-        **kwargs
-    ):
-        pass
-
-    def _open(self):
-        pass
-
-    def _save(self):
-        pass
-
-    def _close(self):
-        pass
-
-    def unload(self):
-        pass
-
-    def all_chunk_coords(self, dimension: Dimension) -> Iterable[ChunkCoordinates]:
-        yield from ()
-
-    def has_chunk(self, cx: int, cz: int, dimension: Dimension) -> bool:
-        return False
-
-    def _delete_chunk(self, cx: int, cz: int, dimension: Dimension):
-        pass
-
-    def _put_raw_chunk_data(self, cx: int, cz: int, data: Any, dimension: Dimension):
-        pass
-
-    def _get_raw_chunk_data(self, cx: int, cz: int, dimension: Dimension) -> Any:
-        raise ChunkDoesNotExist
-
-    def all_player_ids(self) -> Iterable[str]:
-        yield from ()
-
-    def has_player(self, player_id: str) -> bool:
-        return False
-
-    def _load_player(self, player_id: str) -> Player:
-        raise PlayerDoesNotExist
-
-    def _get_raw_player_data(self, player_id: str) -> Any:
-        raise PlayerDoesNotExist
+from typing import Any, List, Dict, Tuple, Optional, TYPE_CHECKING, Iterable, Union
+
+from amulet.api.data_types import (
+    Dimension,
+    PlatformType,
+    ChunkCoordinates,
+    AnyNDArray,
+    VersionNumberTuple,
+)
+from amulet.api.wrapper import FormatWrapper
+from amulet.api.errors import ChunkDoesNotExist, PlayerDoesNotExist
+from amulet.api.player import Player
+from amulet.api.chunk import Chunk
+from amulet.api.selection import SelectionGroup
+from amulet.api import wrapper as api_wrapper
+
+if TYPE_CHECKING:
+    from amulet.api.wrapper import Interface
+
+
+class VoidFormatWrapper(FormatWrapper[VersionNumberTuple]):
+    """
+    A custom :class:`FormatWrapper` class that has no associated data.
+
+    This is just to make the :class:`ImmutableStructure` class happy since it requires a :class:`FormatWrapper` class.
+
+    All methods effectively do nothing.
+    """
+
+    def __init__(self, path: str):
+        super().__init__(path)
+        self._platform = "Unknown Platform"
+        self._version = (0, 0, 0)
+
+    @property
+    def level_name(self) -> str:
+        return "Void"
+
+    @staticmethod
+    def is_valid(path: str) -> bool:
+        return False
+
+    @property
+    def valid_formats(self) -> Dict[PlatformType, Tuple[bool, bool]]:
+        return {}
+
+    @property
+    def dimensions(self) -> List[Dimension]:
+        return ["main"]
+
+    @property
+    def can_add_dimension(self) -> bool:
+        return False
+
+    def register_dimension(self, dimension_identifier: Any):
+        pass
+
+    def _get_interface(self, raw_chunk_data: Optional[Any] = None) -> "Interface":
+        raise Exception("If this is called something is wrong")
+
+    def _encode(
+        self,
+        interface: api_wrapper.Interface,
+        chunk: Chunk,
+        dimension: Dimension,
+        chunk_palette: AnyNDArray,
+    ) -> Any:
+        raise Exception("If this is called something is wrong")
+
+    def _create(
+        self,
+        overwrite: bool,
+        bounds: Union[
+            SelectionGroup, Dict[Dimension, Optional[SelectionGroup]], None
+        ] = None,
+        **kwargs
+    ):
+        pass
+
+    def _open(self):
+        pass
+
+    def _save(self):
+        pass
+
+    def _close(self):
+        pass
+
+    def unload(self):
+        pass
+
+    def all_chunk_coords(self, dimension: Dimension) -> Iterable[ChunkCoordinates]:
+        yield from ()
+
+    def has_chunk(self, cx: int, cz: int, dimension: Dimension) -> bool:
+        return False
+
+    def _delete_chunk(self, cx: int, cz: int, dimension: Dimension):
+        pass
+
+    def _put_raw_chunk_data(self, cx: int, cz: int, data: Any, dimension: Dimension):
+        pass
+
+    def _get_raw_chunk_data(self, cx: int, cz: int, dimension: Dimension) -> Any:
+        raise ChunkDoesNotExist
+
+    def all_player_ids(self) -> Iterable[str]:
+        yield from ()
+
+    def has_player(self, player_id: str) -> bool:
+        return False
+
+    def _load_player(self, player_id: str) -> Player:
+        raise PlayerDoesNotExist
+
+    def _get_raw_player_data(self, player_id: str) -> Any:
+        raise PlayerDoesNotExist

amulet/api/level/structure.py

@@ -1,22 +1,22 @@
-from __future__ import annotations
-
-from .base_level import BaseLevel
-from amulet.api import wrapper as api_wrapper
-
-
-class Structure(BaseLevel):
-    """
-    Class that handles editing of any structure format via an separate and flexible data format
-    """
-
-    def __init__(
-        self,
-        directory: str,
-        structure_wrapper: api_wrapper.StructureFormatWrapper,
-    ):
-        super().__init__(directory, structure_wrapper)
-
-    @property
-    def level_wrapper(self) -> api_wrapper.StructureFormatWrapper:
-        """A class to access data directly from the level."""
-        return self._level_wrapper
+from __future__ import annotations
+
+from .base_level import BaseLevel
+from amulet.api import wrapper as api_wrapper
+
+
+class Structure(BaseLevel):
+    """
+    Class that handles editing of any structure format via an separate and flexible data format
+    """
+
+    def __init__(
+        self,
+        directory: str,
+        structure_wrapper: api_wrapper.StructureFormatWrapper,
+    ):
+        super().__init__(directory, structure_wrapper)
+
+    @property
+    def level_wrapper(self) -> api_wrapper.StructureFormatWrapper:
+        """A class to access data directly from the level."""
+        return self._level_wrapper