amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp311-cp311-win_amd64.whl

amulet/level/abc/_registry.py

@@ -1,40 +0,0 @@
-from typing import overload
-from collections.abc import Mapping, Iterator
-
-
-class IdRegistry(Mapping[int, tuple[str, str]]):
-    def __init__(self) -> None:
-        self._str_to_int: dict[tuple[str, str], int] = {}
-        self._int_to_str: dict[int, tuple[str, str]] = {}
-
-    def numerical_id_to_namespace_id(self, index: int) -> tuple[str, str]:
-        return self._int_to_str[index]
-
-    def namespace_id_to_numerical_id(self, namespace: str, base_name: str) -> int:
-        return self._str_to_int[(namespace, base_name)]
-
-    def register(self, index: int, block_id: tuple[str, str]) -> None:
-        if block_id in self._str_to_int:
-            raise RuntimeError(f"id {block_id} has already been registered")
-        if index in self._int_to_str:
-            raise RuntimeError(f"index {index} has already been registered")
-        self._str_to_int[block_id] = index
-        self._int_to_str[index] = block_id
-
-    @overload
-    def __getitem__(self, key: int) -> tuple[str, str]: ...
-
-    @overload
-    def __getitem__(self, key: tuple[str, str]) -> int: ...
-
-    def __getitem__(self, key: int | tuple[str, str]) -> int | tuple[str, str]:
-        if isinstance(key, int):
-            return self._int_to_str[key]
-        else:
-            return self._str_to_int[key]
-
-    def __len__(self) -> int:
-        return len(self._int_to_str)
-
-    def __iter__(self) -> Iterator[int]:
-        yield from self._int_to_str

amulet/level/java/__init__.pyi

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-from amulet.level.java._level import JavaLevel
-
-from . import (
-    _chunk_handle,
-    _dimension,
-    _level,
-    _raw,
-    anvil,
-    chunk,
-    chunk_components,
-    long_array,
-)
-
-__all__ = ["JavaLevel", "anvil", "chunk", "chunk_components", "long_array"]

amulet/level/java/_chunk_handle.py

@@ -1,17 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from amulet.level.abc import ChunkHandle
-from ..abc._chunk_handle import ChunkT
-from .chunk import JavaChunk
-
-if TYPE_CHECKING:
-    from ._level import JavaLevel
-    from ._raw import JavaRawDimension
-
-
-class JavaChunkHandle(ChunkHandle["JavaLevel", "JavaRawDimension", JavaChunk]):
-    @staticmethod
-    def _validate_chunk(chunk: ChunkT) -> None:
-        if not isinstance(chunk, JavaChunk):
-            raise TypeError

amulet/level/java/_dimension.py

@@ -1,20 +0,0 @@
-from typing import TYPE_CHECKING
-
-from amulet.level.abc import Dimension
-from ._chunk_handle import JavaChunkHandle
-
-if TYPE_CHECKING:
-    from ._level import JavaLevel
-    from ._raw import JavaRawDimension
-
-
-class JavaDimension(Dimension["JavaLevel", "JavaRawDimension", JavaChunkHandle]):
-    def _create_chunk_handle(self, cx: int, cz: int) -> JavaChunkHandle:
-        return JavaChunkHandle(
-            self._l_ref,
-            self._chunk_history,
-            self._chunk_data_history,
-            self.dimension_id,
-            cx,
-            cz,
-        )

amulet/level/java/_level.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Type, Callable
-import os
-import logging
-
-from PIL import Image
-from amulet_nbt import (
-    read_nbt,
-)
-
-from amulet.data_types import DimensionId
-from amulet.level.abc import (
-    DiskLevel,
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-    LevelOpenData,
-    PlayerStorage,
-)
-from amulet.utils.call_spec import (
-    StringArg,
-    IntArg,
-    CallableArg,
-    BoolArg,
-    DirectoryPathArg,
-    PositionalArgs,
-    method_spec,
-)
-from amulet.utils.weakref import DetachableWeakRef
-from amulet.level import register_level_class
-from amulet.version import VersionNumber, PlatformType
-
-from ._dimension import JavaDimension
-from ._raw import JavaCreateArgsV1, JavaRawLevel, InternalDimensionId
-from amulet.chunk import Chunk
-
-log = logging.getLogger(__name__)
-
-
-class JavaLevelOpenData(LevelOpenData):
-    back_reference: Callable[[], JavaLevel | None]
-    detach_back_reference: Callable[[], None]
-    dimensions: dict[DimensionId | InternalDimensionId, JavaDimension]
-
-    def __init__(self, level: JavaLevel) -> None:
-        super().__init__()
-        self.back_reference, self.detach_back_reference = DetachableWeakRef.new(level)
-        self.dimensions = {}
-
-
-class JavaLevel(
-    DiskLevel[JavaLevelOpenData, JavaDimension, JavaRawLevel],
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-):
-    __slots__ = ("_raw_level",)
-
-    def __init__(self, _ikwiad: bool = False) -> None:
-        if not _ikwiad:
-            raise RuntimeError(
-                "BedrockRawLevel must be constructed using the create or load classmethod."
-            )
-        super().__init__()
-
-    def __init(self, raw: JavaRawLevel) -> None:
-        self._raw_level = raw
-        self._raw_level.opened.connect(self.open)
-        self._raw_level.closed.connect(self.close)
-
-    @classmethod
-    @method_spec(
-        CallableArg(
-            JavaCreateArgsV1,
-            BoolArg(True),
-            DirectoryPathArg(),
-            CallableArg(
-                VersionNumber,
-                PositionalArgs(IntArg(min_value=0), (IntArg(1), IntArg(20))),
-            ),
-            StringArg("New World"),
-        )
-    )
-    def create(cls, args: JavaCreateArgsV1) -> JavaLevel:
-        raw = JavaRawLevel.create(args)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    @staticmethod
-    def can_load(token: Any) -> bool:
-        if (
-            isinstance(token, str)
-            and os.path.isdir(token)
-            and os.path.isfile(os.path.join(token, "level.dat"))
-        ):
-            try:
-                level_dat_root = read_nbt(os.path.join(token, "level.dat")).compound
-            except Exception:
-                pass
-            else:
-                return "Data" in level_dat_root and "FML" not in level_dat_root
-        return False
-
-    @classmethod
-    def load(cls, path: str) -> JavaLevel:
-        raw = JavaRawLevel.load(path)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    def reload(self) -> None:
-        self.raw.reload()
-
-    def _open(self) -> None:
-        self.raw.open()
-        self._open_data = JavaLevelOpenData(self)
-
-    def _close(self) -> None:
-        self._o.detach_back_reference()
-        self._open_data = None
-        self.raw.close()
-
-    def save(self) -> None:
-        raise NotImplementedError
-
-    @property
-    def platform(self) -> PlatformType:
-        return self.raw.platform
-
-    @property
-    def max_game_version(self) -> VersionNumber:
-        return self.raw.data_version
-
-    @property
-    def level_name(self) -> str:
-        return self.raw.level_name
-
-    @property
-    def modified_time(self) -> float:
-        return self.raw.modified_time
-
-    @property
-    def path(self) -> str:
-        return self.raw.path
-
-    @property
-    def thumbnail(self) -> Image.Image:
-        try:
-            return Image.open(os.path.join(self.path, "icon.png"))
-        except Exception:
-            return super().thumbnail
-
-    def dimension_ids(self) -> frozenset[DimensionId]:
-        return self.raw.dimension_ids()
-
-    def get_dimension(
-        self, dimension_id: DimensionId | InternalDimensionId
-    ) -> JavaDimension:
-        if dimension_id not in self._o.dimensions:
-            raw_dimension = self.raw.get_dimension(dimension_id)
-            self._o.dimensions[raw_dimension.dimension_id] = self._o.dimensions[
-                raw_dimension.relative_path
-            ] = JavaDimension(self._o.back_reference, raw_dimension.dimension_id)
-        return self._o.dimensions[dimension_id]
-
-    @property
-    def player(self) -> PlayerStorage:
-        raise NotImplementedError
-
-    @property
-    def native_chunk_class(self) -> Type[Chunk]:
-        raise NotImplementedError
-
-    @property
-    def raw(self) -> JavaRawLevel:
-        return self._raw_level
-
-    def compact(self) -> None:
-        self.raw.compact()
-
-
-register_level_class(JavaLevel)

amulet/level/java/_raw/__init__.pyi

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from builtins import str as InternalDimensionId
-
-from amulet.level.java._raw._dimension import JavaRawDimension
-from amulet.level.java._raw._level import JavaCreateArgsV1, JavaRawLevel
-
-from . import _chunk, _constant, _data_pack, _dimension, _level, _typing
-
-__all__ = [
-    "InternalDimensionId",
-    "JavaCreateArgsV1",
-    "JavaRawDimension",
-    "JavaRawLevel",
-]

amulet/level/java/_raw/_chunk.pyi

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-import amulet.level.java.chunk
-import amulet_nbt
-
-__all__ = ["decode_chunk", "encode_chunk"]
-
-def decode_chunk(
-    arg0: typing.Any,
-    arg1: typing.Any,
-    arg2: dict[str, amulet_nbt.NamedTag],
-    arg3: int,
-    arg4: int,
-) -> amulet.level.java.chunk.JavaChunk: ...
-def encode_chunk(
-    arg0: typing.Any,
-    arg1: typing.Any,
-    arg2: amulet.level.java.chunk.JavaChunk,
-    arg3: int,
-    arg4: int,
-) -> dict[str, amulet_nbt.NamedTag]: ...

amulet/level/java/_raw/_constant.py

@@ -1,9 +0,0 @@
-from amulet.selection import SelectionBox, SelectionGroup
-
-OVERWORLD = "minecraft:overworld"
-THE_NETHER = "minecraft:the_nether"
-THE_END = "minecraft:the_end"
-
-DefaultSelection = SelectionGroup(
-    SelectionBox((-30_000_000, 0, -30_000_000), (30_000_000, 256, 30_000_000))
-)

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

@@ -1,2 +0,0 @@
-from .data_pack import DataPack
-from .data_pack_manager import DataPackManager

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

@@ -1,241 +0,0 @@
-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_manager.py

@@ -1,77 +0,0 @@
-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()