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

amulet/api/wrapper/structure_format_wrapper.py

@@ -1,116 +1,116 @@
-from abc import abstractmethod
-from typing import BinaryIO, List, Any, Tuple, Iterable, Union, Optional, Dict
-import os
-
-from .format_wrapper import FormatWrapper, VersionNumberT
-from amulet.api.data_types import Dimension
-from amulet.api.errors import ObjectReadError, ObjectReadWriteError, PlayerDoesNotExist
-from amulet.api.player import Player
-from amulet.api.selection import SelectionGroup
-
-
-class StructureFormatWrapper(FormatWrapper[VersionNumberT]):
-    """A base FormatWrapper for all structures that only have one dimension."""
-
-    def __init__(self, path: str):
-        """
-        Construct a new instance of :class:`StructureFormatWrapper`.
-
-        This should not be used directly. You should instead use :func:`amulet.load_format`.
-
-        :param path: The file path to the serialised data.
-        """
-        super().__init__(path)
-        if self.extensions:
-            ext = os.path.splitext(self._path)[1]
-            if ext not in self.extensions:
-                raise ObjectReadWriteError(
-                    f"The given file does not have a valid file extension. Must be one of {self.extensions}"
-                )
-
-    @property
-    def level_name(self) -> str:
-        return os.path.basename(self.path)
-
-    @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
-
-    @property
-    def requires_selection(self) -> bool:
-        return True
-
-    @property
-    @abstractmethod
-    def extensions(self) -> Tuple[str, ...]:
-        """
-        The extension the file can have to be valid.
-
-        eg (".schematic",)
-        """
-        raise NotImplementedError
-
-    def _set_selection(
-        self,
-        bounds: Union[SelectionGroup, Dict[Dimension, Optional[SelectionGroup]], None],
-    ):
-        if isinstance(bounds, SelectionGroup):
-            bounds = self._clean_selection(bounds)
-            self._bounds = {dim: bounds for dim in self.dimensions}
-        elif isinstance(bounds, dict):
-            for dim in self.dimensions:
-                group = bounds.get(dim, None)
-                if isinstance(group, SelectionGroup):
-                    self._bounds[dim] = self._clean_selection(group)
-        else:
-            raise ObjectReadError("A selection was required but none were given.")
-
-    @abstractmethod
-    def open_from(self, f: BinaryIO):
-        """
-        Load from a file like object. Useful to load from RAM rather than disk.
-
-        :param f: The file like object to read data from.
-        """
-        raise NotImplementedError
-
-    def _open(self):
-        if not os.path.isfile(self._path):
-            raise ObjectReadError(f"There is no file to read at {self._path}")
-        with open(self._path, "rb") as f:
-            self.open_from(f)
-        self._is_open = True
-        self._has_lock = True
-
-    @abstractmethod
-    def save_to(self, f: BinaryIO):
-        """
-        Write to a file like object. Useful to write to RAM rather than disk.
-
-        :param f: The file like object to write data to.
-        """
-        raise NotImplementedError
-
-    def _save(self):
-        os.makedirs(os.path.dirname(self._path), exist_ok=True)
-        with open(self._path, "wb") as f:
-            self.save_to(f)
-
-    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 abc import abstractmethod
+from typing import BinaryIO, List, Any, Tuple, Iterable, Union, Optional, Dict
+import os
+
+from .format_wrapper import FormatWrapper, VersionNumberT
+from amulet.api.data_types import Dimension
+from amulet.api.errors import ObjectReadError, ObjectReadWriteError, PlayerDoesNotExist
+from amulet.api.player import Player
+from amulet.api.selection import SelectionGroup
+
+
+class StructureFormatWrapper(FormatWrapper[VersionNumberT]):
+    """A base FormatWrapper for all structures that only have one dimension."""
+
+    def __init__(self, path: str):
+        """
+        Construct a new instance of :class:`StructureFormatWrapper`.
+
+        This should not be used directly. You should instead use :func:`amulet.load_format`.
+
+        :param path: The file path to the serialised data.
+        """
+        super().__init__(path)
+        if self.extensions:
+            ext = os.path.splitext(self._path)[1]
+            if ext not in self.extensions:
+                raise ObjectReadWriteError(
+                    f"The given file does not have a valid file extension. Must be one of {self.extensions}"
+                )
+
+    @property
+    def level_name(self) -> str:
+        return os.path.basename(self.path)
+
+    @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
+
+    @property
+    def requires_selection(self) -> bool:
+        return True
+
+    @property
+    @abstractmethod
+    def extensions(self) -> Tuple[str, ...]:
+        """
+        The extension the file can have to be valid.
+
+        eg (".schematic",)
+        """
+        raise NotImplementedError
+
+    def _set_selection(
+        self,
+        bounds: Union[SelectionGroup, Dict[Dimension, Optional[SelectionGroup]], None],
+    ):
+        if isinstance(bounds, SelectionGroup):
+            bounds = self._clean_selection(bounds)
+            self._bounds = {dim: bounds for dim in self.dimensions}
+        elif isinstance(bounds, dict):
+            for dim in self.dimensions:
+                group = bounds.get(dim, None)
+                if isinstance(group, SelectionGroup):
+                    self._bounds[dim] = self._clean_selection(group)
+        else:
+            raise ObjectReadError("A selection was required but none were given.")
+
+    @abstractmethod
+    def open_from(self, f: BinaryIO):
+        """
+        Load from a file like object. Useful to load from RAM rather than disk.
+
+        :param f: The file like object to read data from.
+        """
+        raise NotImplementedError
+
+    def _open(self):
+        if not os.path.isfile(self._path):
+            raise ObjectReadError(f"There is no file to read at {self._path}")
+        with open(self._path, "rb") as f:
+            self.open_from(f)
+        self._is_open = True
+        self._has_lock = True
+
+    @abstractmethod
+    def save_to(self, f: BinaryIO):
+        """
+        Write to a file like object. Useful to write to RAM rather than disk.
+
+        :param f: The file like object to write data to.
+        """
+        raise NotImplementedError
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self._path), exist_ok=True)
+        with open(self._path, "wb") as f:
+            self.save_to(f)
+
+    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/wrapper/world_format_wrapper.py

@@ -1,63 +1,63 @@
-from abc import abstractmethod
-import os
-from typing import Any, Optional, TYPE_CHECKING
-
-from amulet import IMG_DIRECTORY
-from .format_wrapper import FormatWrapper, VersionNumberT
-
-if TYPE_CHECKING:
-    from amulet.api.wrapper import Interface
-
-missing_world_icon = os.path.abspath(
-    os.path.join(IMG_DIRECTORY, "missing_world_icon.png")
-)
-
-
-class WorldFormatWrapper(FormatWrapper[VersionNumberT]):
-    _missing_world_icon = missing_world_icon
-
-    def __init__(self, path: str):
-        """
-        Construct a new instance of :class:`WorldFormatWrapper`.
-
-        This should not be used directly. You should instead use :func:`amulet.load_format`.
-
-        :param path: The file path to the serialised data.
-        """
-        super().__init__(path)
-        self._world_image_path = missing_world_icon
-
-    @property
-    @abstractmethod
-    def level_name(self) -> str:
-        raise NotImplementedError
-
-    @level_name.setter
-    @abstractmethod
-    def level_name(self, value: str):
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def last_played(self) -> int:
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def game_version_string(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def world_image_path(self) -> str:
-        """The path to the world icon."""
-        return self._world_image_path
-
-    @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 NotImplementedError
+from abc import abstractmethod
+import os
+from typing import Any, Optional, TYPE_CHECKING
+
+from amulet import IMG_DIRECTORY
+from .format_wrapper import FormatWrapper, VersionNumberT
+
+if TYPE_CHECKING:
+    from amulet.api.wrapper import Interface
+
+missing_world_icon = os.path.abspath(
+    os.path.join(IMG_DIRECTORY, "missing_world_icon.png")
+)
+
+
+class WorldFormatWrapper(FormatWrapper[VersionNumberT]):
+    _missing_world_icon = missing_world_icon
+
+    def __init__(self, path: str):
+        """
+        Construct a new instance of :class:`WorldFormatWrapper`.
+
+        This should not be used directly. You should instead use :func:`amulet.load_format`.
+
+        :param path: The file path to the serialised data.
+        """
+        super().__init__(path)
+        self._world_image_path = missing_world_icon
+
+    @property
+    @abstractmethod
+    def level_name(self) -> str:
+        raise NotImplementedError
+
+    @level_name.setter
+    @abstractmethod
+    def level_name(self, value: str):
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def last_played(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def game_version_string(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def world_image_path(self) -> str:
+        """The path to the world icon."""
+        return self._world_image_path
+
+    @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 NotImplementedError

amulet/level/__init__.py

@@ -1 +1 @@
-from .load import load_format, load_level
+from .load import load_format, load_level

amulet/level/formats/anvil_forge_world.py

@@ -1,40 +1,40 @@
-from __future__ import annotations
-import glob
-import os
-
-from amulet_nbt import load as load_nbt
-
-from .anvil_world import AnvilFormat
-from amulet.utils.format_utils import check_all_exist
-
-
-class AnvilForgeFormat(AnvilFormat):
-    """
-    This FormatWrapper class is a modification on the :class:`AnvilFormat` class that separates Forge worlds from vanilla worlds.
-
-    Currently there is no extra logic here but this should extend the :class:`AnvilFormat` class to support Forge worlds.
-    """
-
-    @staticmethod
-    def is_valid(path: str) -> bool:
-        if not check_all_exist(path, "level.dat"):
-            return False
-
-        try:
-            level_dat_root = load_nbt(os.path.join(path, "level.dat")).compound
-        except:
-            return False
-
-        return "Data" in level_dat_root and (
-            "FML" in level_dat_root or "fml" in level_dat_root
-        )
-
-    @property
-    def game_version_string(self) -> str:
-        try:
-            return f'Java Forge {self.root_tag.compound.get_compound("Data").get_compound("Version").get_string("Name").py_str}'
-        except Exception:
-            return f"Java Forge Unknown Version"
-
-
-export = AnvilForgeFormat
+from __future__ import annotations
+import glob
+import os
+
+from amulet_nbt import load as load_nbt
+
+from .anvil_world import AnvilFormat
+from amulet.utils.format_utils import check_all_exist
+
+
+class AnvilForgeFormat(AnvilFormat):
+    """
+    This FormatWrapper class is a modification on the :class:`AnvilFormat` class that separates Forge worlds from vanilla worlds.
+
+    Currently there is no extra logic here but this should extend the :class:`AnvilFormat` class to support Forge worlds.
+    """
+
+    @staticmethod
+    def is_valid(path: str) -> bool:
+        if not check_all_exist(path, "level.dat"):
+            return False
+
+        try:
+            level_dat_root = load_nbt(os.path.join(path, "level.dat")).compound
+        except:
+            return False
+
+        return "Data" in level_dat_root and (
+            "FML" in level_dat_root or "fml" in level_dat_root
+        )
+
+    @property
+    def game_version_string(self) -> str:
+        try:
+            return f'Java Forge {self.root_tag.compound.get_compound("Data").get_compound("Version").get_string("Name").py_str}'
+        except Exception:
+            return f"Java Forge Unknown Version"
+
+
+export = AnvilForgeFormat

amulet/level/formats/anvil_world/__init__.py

@@ -1,3 +1,3 @@
-from .format import AnvilFormat
-
-export = AnvilFormat
+from .format import AnvilFormat
+
+export = AnvilFormat