amulet-core 2.0a5__cp311-cp311-macosx_10_9_universal2.whl

amulet/level/java/_raw/_data_pack/data_pack.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Iterable, Protocol
+from types import TracebackType
+import os
+import json
+from zipfile import ZipFile
+import re
+
+
+class Readable(Protocol):
+    def read(self, n: int = -1) -> bytes: ...
+
+    def __enter__(self) -> Readable: ...
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+
+
+class BaseWrapper(ABC):
+    def __init__(self, path: str):
+        self._path = path
+
+    @staticmethod
+    @abstractmethod
+    def is_valid(path: str) -> bool:
+        """
+        Is the given path valid for this class.
+
+        :param path: The path to test.
+        """
+
+    @property
+    def path(self) -> str:
+        """The path to the data."""
+        return self._path
+
+    @property
+    @abstractmethod
+    def all_files(self) -> Iterable[str]:
+        """
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+        """
+        raise NotImplementedError
+
+    def all_files_match(self, match: str) -> Iterable[str]:
+        """
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+        """
+        re_match = re.compile(match)
+        return tuple(path for path in self.all_files if re_match.fullmatch(path))
+
+    @abstractmethod
+    def has_file(self, relative_path: str) -> bool:
+        """
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def open(self, relative_path: str) -> Readable:
+        """
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the contents."""
+        raise NotImplementedError
+
+
+class ZipWrapper(BaseWrapper):
+    def __init__(self, path: str):
+        BaseWrapper.__init__(self, path)
+        self._zip_file = ZipFile(path)
+
+    @staticmethod
+    def is_valid(path: str) -> bool:
+        return os.path.isfile(path) and path.endswith(".zip")
+
+    @property
+    def all_files(self) -> Iterable[str]:
+        for path in self._zip_file.NameToInfo:
+            if not path.endswith("/"):
+                yield path
+
+    def has_file(self, relative_path: str) -> bool:
+        if relative_path.endswith("/"):
+            # is a directory
+            return False
+        else:
+            return relative_path in self._zip_file.NameToInfo
+
+    def open(self, name: str) -> Readable:
+        return self._zip_file.open(name)
+
+    def close(self) -> None:
+        self._zip_file.close()
+
+
+class DirWrapper(BaseWrapper):
+    def __init__(self, path: str):
+        BaseWrapper.__init__(self, path)
+
+    @staticmethod
+    def is_valid(path: str) -> bool:
+        return os.path.isdir(path)
+
+    @property
+    def all_files(self) -> Iterable[str]:
+        for abs_path, _, files in os.walk(self.path):
+            rel_path = os.path.normpath(os.path.relpath(abs_path, self.path)).replace(
+                os.sep, "/"
+            )
+            if rel_path == ".":
+                yield from files
+            else:
+                for f in files:
+                    yield f"{rel_path}/{f}"
+
+    def has_file(self, relative_path: str) -> bool:
+        return os.path.isfile(os.path.join(self.path, relative_path))
+
+    def open(self, relative_path: str) -> Readable:
+        return open(os.path.join(self.path, relative_path), "rb")
+
+    def close(self) -> None:
+        pass
+
+
+def _open_wrapper(path: str) -> BaseWrapper:
+    for cls in (ZipWrapper, DirWrapper):
+        if cls.is_valid(path):
+            return cls(path)
+    raise FileNotFoundError(f"The given path {path} is not valid.")
+
+
+class DataPack:
+    """The DataPack class wraps a single data pack."""
+
+    def __init__(self, path: str):
+        self._path = path
+        self._wrapper = _open_wrapper(path)
+        self._is_valid = self.is_wrapper_valid(self._wrapper)
+
+    @property
+    def path(self) -> str:
+        """The path to the data."""
+        return self._path
+
+    @staticmethod
+    def is_path_valid(path: str) -> bool:
+        """
+        Check if the given path is a valid data pack.
+
+        :param path: The path to the data pack. Can be a zip file or directory.
+        :return: True if the path is a valid data pack, False otherwise.
+        """
+        try:
+            wrapper = _open_wrapper(path)
+        except FileNotFoundError:
+            return False
+        is_valid = DataPack.is_wrapper_valid(wrapper)
+        wrapper.close()
+        return is_valid
+
+    @property
+    def is_valid(self) -> bool:
+        return self._is_valid
+
+    @staticmethod
+    def is_wrapper_valid(wrapper: BaseWrapper) -> bool:
+        if wrapper.has_file("pack.mcmeta"):
+            with wrapper.open("pack.mcmeta") as m:
+                try:
+                    meta_file = json.load(m)
+                except json.JSONDecodeError:
+                    pass
+                else:
+                    if isinstance(meta_file, dict) and isinstance(
+                        meta_file.get("pack", {}).get("pack_format", None), int
+                    ):
+                        # TODO: check the actual value
+                        return True
+        return False
+
+    @property
+    def all_files(self) -> Iterable[str]:
+        """
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+        """
+        return self._wrapper.all_files
+
+    def all_files_match(self, match: str) -> Iterable[str]:
+        """
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+        """
+        return self._wrapper.all_files_match(match)
+
+    def has_file(self, relative_path: str) -> bool:
+        """
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+        """
+        return self._wrapper.has_file(relative_path)
+
+    def open(self, relative_path: str) -> Readable:
+        """
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+        """
+        return self._wrapper.open(relative_path)
+
+    def close(self) -> None:
+        """Close the contents."""
+        self._wrapper.close()

amulet/level/java/_raw/_data_pack/data_pack.pyi

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import abc
+import json as json
+import os as os
+import re as re
+import typing
+from abc import ABC, abstractmethod
+from builtins import traceback as TracebackType
+from typing import Protocol
+from zipfile import ZipFile
+
+__all__ = [
+    "ABC",
+    "BaseWrapper",
+    "DataPack",
+    "DirWrapper",
+    "Protocol",
+    "Readable",
+    "TracebackType",
+    "ZipFile",
+    "ZipWrapper",
+    "abstractmethod",
+    "json",
+    "os",
+    "re",
+]
+
+class BaseWrapper(abc.ABC):
+    @staticmethod
+    def is_valid(path: str) -> bool:
+        """
+
+        Is the given path valid for this class.
+
+        :param path: The path to test.
+
+        """
+
+    def __init__(self, path: str): ...
+    def all_files_match(self, match: str) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+
+        """
+
+    def close(self) -> None:
+        """
+        Close the contents.
+        """
+
+    def has_file(self, relative_path: str) -> bool:
+        """
+
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    def open(self, relative_path: str) -> Readable:
+        """
+
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    @property
+    def all_files(self) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+
+        """
+
+    @property
+    def path(self) -> str:
+        """
+        The path to the data.
+        """
+
+class DataPack:
+    """
+    The DataPack class wraps a single data pack.
+    """
+
+    @staticmethod
+    def is_path_valid(path: str) -> bool:
+        """
+
+        Check if the given path is a valid data pack.
+
+        :param path: The path to the data pack. Can be a zip file or directory.
+        :return: True if the path is a valid data pack, False otherwise.
+
+        """
+
+    @staticmethod
+    def is_wrapper_valid(wrapper: BaseWrapper) -> bool: ...
+    def __init__(self, path: str): ...
+    def all_files_match(self, match: str) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+
+        """
+
+    def close(self) -> None:
+        """
+        Close the contents.
+        """
+
+    def has_file(self, relative_path: str) -> bool:
+        """
+
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    def open(self, relative_path: str) -> Readable:
+        """
+
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    @property
+    def all_files(self) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+
+        """
+
+    @property
+    def is_valid(self) -> bool: ...
+    @property
+    def path(self) -> str:
+        """
+        The path to the data.
+        """
+
+class DirWrapper(BaseWrapper):
+    @staticmethod
+    def is_valid(path: str) -> bool: ...
+    def __init__(self, path: str): ...
+    def close(self) -> None: ...
+    def has_file(self, relative_path: str) -> bool: ...
+    def open(self, relative_path: str) -> Readable: ...
+    @property
+    def all_files(self) -> typing.Iterable[str]: ...
+
+class Readable(typing.Protocol):
+    @classmethod
+    def __subclasshook__(cls, other): ...
+    def __enter__(self) -> Readable: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+    def __init__(self, *args, **kwargs): ...
+    def read(self, n: int = -1) -> bytes: ...
+
+class ZipWrapper(BaseWrapper):
+    @staticmethod
+    def is_valid(path: str) -> bool: ...
+    def __init__(self, path: str): ...
+    def close(self) -> None: ...
+    def has_file(self, relative_path: str) -> bool: ...
+    def open(self, name: str) -> Readable: ...
+    @property
+    def all_files(self) -> typing.Iterable[str]: ...
+
+def _open_wrapper(path: str) -> BaseWrapper: ...

amulet/level/java/_raw/_data_pack/data_pack_manager.py

@@ -0,0 +1,77 @@
+from typing import Iterable
+from .data_pack import DataPack, Readable
+
+
+class DataPackManager:
+    """
+    The DataPackManager class contains one or more data packs.
+    It manages loading them so that the stacking order is maintained.
+    """
+
+    def __init__(self, data_packs: Iterable[DataPack]):
+        """
+        Construct a new DataPackManager class.
+
+        :param data_packs: The data packs to load from. Later in the list get higher priority.
+        """
+        self._data_packs = tuple(
+            reversed(
+                tuple(
+                    pack
+                    for pack in data_packs
+                    if isinstance(pack, DataPack) and pack.is_valid
+                )
+            )
+        )
+
+    @property
+    def all_files(self) -> Iterable[str]:
+        """
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+        """
+        all_files: set[str] = set()
+        for pack in self._data_packs:
+            all_files.update(pack.all_files)
+        return all_files
+
+    def all_files_match(self, match: str) -> Iterable[str]:
+        """
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+        """
+        all_files: set[str] = set()
+        for pack in self._data_packs:
+            all_files.update(pack.all_files_match(match))
+        return all_files
+
+    def has_file(self, relative_path: str) -> bool:
+        """
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+        """
+        return any(pack.has_file(relative_path) for pack in self._data_packs)
+
+    def open(self, relative_path: str) -> Readable:
+        """
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+        """
+        for pack in self._data_packs:
+            if pack.has_file(relative_path):
+                return pack.open(relative_path)
+        raise FileNotFoundError(
+            f"The requested path {relative_path} could not be found."
+        )
+
+    def close(self) -> None:
+        """Close the contents."""
+        for pack in self._data_packs:
+            pack.close()

amulet/level/java/_raw/_data_pack/data_pack_manager.pyi

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import amulet.level.java._raw._data_pack.data_pack
+from amulet.level.java._raw._data_pack.data_pack import DataPack, Readable
+
+__all__ = ["DataPack", "DataPackManager", "Readable"]
+
+class DataPackManager:
+    """
+
+    The DataPackManager class contains one or more data packs.
+    It manages loading them so that the stacking order is maintained.
+
+    """
+
+    def __init__(
+        self,
+        data_packs: typing.Iterable[
+            amulet.level.java._raw._data_pack.data_pack.DataPack
+        ],
+    ):
+        """
+
+        Construct a new DataPackManager class.
+
+        :param data_packs: The data packs to load from. Later in the list get higher priority.
+
+        """
+
+    def all_files_match(self, match: str) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within that match the given regex.
+
+        :param match: The regex string to match again.
+        :return: An iterable of file paths that match the given regex.
+
+        """
+
+    def close(self) -> None:
+        """
+        Close the contents.
+        """
+
+    def has_file(self, relative_path: str) -> bool:
+        """
+
+        Does the requested file exist.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    def open(
+        self, relative_path: str
+    ) -> amulet.level.java._raw._data_pack.data_pack.Readable:
+        """
+
+        Get the contents of the file.
+
+        :param relative_path:
+        :return:
+
+        """
+
+    @property
+    def all_files(self) -> typing.Iterable[str]:
+        """
+
+        The relative paths of all files contained within.
+
+        :return: An iterable of paths.
+
+        """

amulet/level/java/_raw/_dimension.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+from typing import Iterable, TYPE_CHECKING, Callable
+
+from amulet.biome import Biome
+from amulet.block import BlockStack
+from amulet.data_types import DimensionId, ChunkCoordinates
+from amulet.level.abc import RawDimension, RawLevelFriend
+from amulet.selection import SelectionGroup
+
+from amulet.level.java.anvil import RawChunkType, AnvilDimension
+from amulet.level.java.chunk import JavaChunk
+from ._typing import InternalDimensionId
+
+from ._chunk import decode_chunk, encode_chunk
+
+
+if TYPE_CHECKING:
+    from ._level import JavaRawLevel
+
+
+class JavaRawDimension(
+    RawLevelFriend["JavaRawLevel"], RawDimension[RawChunkType, JavaChunk]
+):
+    def __init__(
+        self,
+        raw_level_ref: Callable[[], JavaRawLevel | None],
+        anvil_dimension: AnvilDimension,
+        relative_path: InternalDimensionId,
+        dimension_id: DimensionId,
+        bounds: SelectionGroup,
+        default_block: BlockStack,
+        default_biome: Biome,
+    ) -> None:
+        super().__init__(raw_level_ref)
+        self._anvil_dimension = anvil_dimension
+        self._relative_path = relative_path
+        self._dimension_id = dimension_id
+        self._bounds = bounds
+        self._default_block = default_block
+        self._default_biome = default_biome
+
+    @property
+    def dimension_id(self) -> DimensionId:
+        return self._dimension_id
+
+    @property
+    def relative_path(self) -> InternalDimensionId:
+        return self._relative_path
+
+    def bounds(self) -> SelectionGroup:
+        return self._bounds
+
+    def default_block(self) -> BlockStack:
+        return self._default_block
+
+    def default_biome(self) -> Biome:
+        return self._default_biome
+
+    def all_chunk_coords(self) -> Iterable[ChunkCoordinates]:
+        yield from self._anvil_dimension.all_chunk_coords()
+
+    def has_chunk(self, cx: int, cz: int) -> bool:
+        return self._anvil_dimension.has_chunk(cx, cz)
+
+    def delete_chunk(self, cx: int, cz: int) -> None:
+        self._anvil_dimension.delete_chunk(cx, cz)
+
+    def get_raw_chunk(self, cx: int, cz: int) -> RawChunkType:
+        return self._anvil_dimension.get_chunk_data(cx, cz)
+
+    def set_raw_chunk(self, cx: int, cz: int, chunk: RawChunkType) -> None:
+        self._anvil_dimension.put_chunk_data(cx, cz, chunk)
+
+    def raw_chunk_to_native_chunk(
+        self, raw_chunk: RawChunkType, cx: int, cz: int
+    ) -> JavaChunk:
+        return decode_chunk(self._r, self, raw_chunk, cx, cz)
+
+    def native_chunk_to_raw_chunk(
+        self, chunk: JavaChunk, cx: int, cz: int
+    ) -> RawChunkType:
+        return encode_chunk(self._r, self, chunk, cx, cz)
+
+    def compact(self) -> None:
+        """Compact all region files"""
+        self._anvil_dimension.compact()