amulet-core 2.0a5__cp312-cp312-win_amd64.whl → 2.0a7__cp312-cp312-win_amd64.whl

amulet/chunk_/components/height_2d.py

@@ -1,16 +0,0 @@
-# import numpy
-# from numpy.typing import ArrayLike
-# from .abc import ChunkComponent
-#
-#
-# class Height2DComponent(ChunkComponent[numpy.ndarray, ArrayLike]):
-#     storage_key = b"h2d"
-#
-#     @staticmethod
-#     def fix_set_data(old_obj: numpy.ndarray, new_obj: ArrayLike) -> numpy.ndarray:
-#         new_obj = numpy.asarray(new_obj, numpy.int64)
-#         if not isinstance(new_obj, numpy.ndarray):
-#             raise TypeError
-#         if new_obj.shape != old_obj.shape or new_obj.dtype != numpy.int64:
-#             raise ValueError
-#         return new_obj

amulet/level/bedrock/__init__.py

@@ -1,2 +0,0 @@
-from ._level import BedrockLevel
-from ._raw import BedrockLevelDAT, BedrockCreateArgsV1

amulet/level/bedrock/_chunk_handle.py

@@ -1,19 +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 BedrockChunk
-
-if TYPE_CHECKING:
-    from ._level import BedrockLevel
-    from ._raw import BedrockRawDimension
-
-
-class BedrockChunkHandle(
-    ChunkHandle["BedrockLevel", "BedrockRawDimension", BedrockChunk]
-):
-    @staticmethod
-    def _validate_chunk(chunk: ChunkT) -> None:
-        if not isinstance(chunk, BedrockChunk):
-            raise TypeError

amulet/level/bedrock/_dimension.py

@@ -1,22 +0,0 @@
-from typing import TYPE_CHECKING
-
-from amulet.level.abc import Dimension
-from ._chunk_handle import BedrockChunkHandle
-
-if TYPE_CHECKING:
-    from ._level import BedrockLevel
-    from ._raw import BedrockRawDimension
-
-
-class BedrockDimension(
-    Dimension["BedrockLevel", "BedrockRawDimension", BedrockChunkHandle]
-):
-    def _create_chunk_handle(self, cx: int, cz: int) -> BedrockChunkHandle:
-        return BedrockChunkHandle(
-            self._l_ref,
-            self._chunk_history,
-            self._chunk_data_history,
-            self.dimension_id,
-            cx,
-            cz,
-        )

amulet/level/bedrock/_level.py

@@ -1,187 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Union, Type, Callable
-import os
-
-from PIL import Image
-
-from amulet.version import VersionNumber, PlatformType
-from amulet.data_types import DimensionId
-from amulet.level import register_level_class
-from amulet.level.abc import (
-    LevelOpenData,
-    DiskLevel,
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-    PlayerStorage,
-)
-from amulet.utils.format_utils import check_all_exist
-from amulet.utils.call_spec import (
-    StringArg,
-    IntArg,
-    CallableArg,
-    BoolArg,
-    DirectoryPathArg,
-    PositionalArgs,
-    method_spec,
-)
-from amulet.utils.weakref import DetachableWeakRef
-
-from ._raw import BedrockRawLevel, InternalDimension, BedrockCreateArgsV1
-from ._dimension import BedrockDimension
-from ...chunk import Chunk
-
-
-class BedrockLevelOpenData(LevelOpenData):
-    back_reference: Callable[[], BedrockLevel | None]
-    detach_back_reference: Callable[[], None]
-    dimensions: dict[Union[DimensionId, InternalDimension], BedrockDimension]
-
-    def __init__(self, level: BedrockLevel) -> None:
-        super().__init__()
-        self.back_reference, self.detach_back_reference = DetachableWeakRef.new(level)
-        self.dimensions = {}
-
-
-class BedrockLevel(
-    DiskLevel[BedrockLevelOpenData, BedrockDimension, BedrockRawLevel],
-    CreatableLevel,
-    LoadableLevel,
-    CompactableLevel,
-):
-    def save(self) -> None:
-        pass
-
-    @property
-    def native_chunk_class(self) -> Type[Chunk]:
-        raise NotImplementedError
-
-    _raw_level: BedrockRawLevel
-
-    __slots__ = ("_raw_level",)
-
-    def __init__(self, _ikwiad: bool = False) -> None:
-        if not _ikwiad:
-            raise RuntimeError(
-                "BedrockLevel cannot be directly initialised. Use create or load classmethod."
-            )
-        super().__init__()
-
-    def __init(self, raw: BedrockRawLevel) -> None:
-        self._raw_level = raw
-        self._raw_level.opened.connect(self.open)
-        self._raw_level.closed.connect(self.close)
-
-    @classmethod
-    @method_spec(
-        CallableArg(
-            BedrockCreateArgsV1,
-            BoolArg(True),
-            DirectoryPathArg(),
-            CallableArg(
-                VersionNumber,
-                PositionalArgs(IntArg(min_value=0), (IntArg(1), IntArg(20))),
-            ),
-            StringArg("New World"),
-        )
-    )
-    def create(cls, args: BedrockCreateArgsV1) -> BedrockLevel:
-        raw = BedrockRawLevel.create(args)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    @staticmethod
-    def can_load(token: Any) -> bool:
-        return (
-            isinstance(token, str)
-            and os.path.isdir(token)
-            and check_all_exist(token, "db", "level.dat", "levelname.txt")
-        )
-
-    @classmethod
-    def load(cls, path: str) -> BedrockLevel:
-        """Create a new instance from the level at the given directory."""
-        raw = BedrockRawLevel.load(path)
-        self = cls(True)
-        self.__init(raw)
-        return self
-
-    def reload(self) -> None:
-        """
-        Reload the level metadata inplace.
-        The level must be closed when this is called.
-        """
-        self.raw.reload()
-
-    def _open(self) -> None:
-        self.raw.open()
-        self._open_data = BedrockLevelOpenData(self)
-
-    def _close(self) -> None:
-        self._o.detach_back_reference()
-        self._open_data = None
-        self.raw.close()
-
-    @property
-    def path(self) -> str:
-        return self.raw.path
-
-    @property
-    def level_name(self) -> str:
-        try:
-            level_name_tag = self.raw.level_dat.compound.get_string("LevelName")
-            assert level_name_tag is not None
-            return level_name_tag.py_str
-        except Exception:
-            return "Unknown level name"
-
-    @property
-    def modified_time(self) -> float:
-        return self.raw.modified_time
-
-    @property
-    def thumbnail(self) -> Image.Image:
-        try:
-            return Image.open(os.path.join(self.path, "world_icon.jpeg"))
-        except Exception:
-            return super().thumbnail
-
-    @property
-    def platform(self) -> PlatformType:
-        return "bedrock"
-
-    @property
-    def max_game_version(self) -> VersionNumber:
-        return self.raw.version
-
-    def dimension_ids(self) -> frozenset[DimensionId]:
-        return self.raw.dimension_ids()
-
-    def get_dimension(
-        self, dimension_id: Union[DimensionId, InternalDimension]
-    ) -> BedrockDimension:
-        dimensions = self._o.dimensions
-        if dimension_id not in dimensions:
-            raw_dimension = self.raw.get_dimension(dimension_id)
-            public_dimension_id = raw_dimension.dimension_id
-            internal_dimension_id = raw_dimension.internal_dimension_id
-            dimensions[internal_dimension_id] = dimensions[public_dimension_id] = (
-                BedrockDimension(self._o.back_reference, public_dimension_id)
-            )
-        return dimensions[dimension_id]
-
-    @property
-    def raw(self) -> BedrockRawLevel:
-        return self._raw_level
-
-    @property
-    def player(self) -> PlayerStorage:
-        raise NotImplementedError
-
-    def compact(self) -> None:
-        self.raw.level_db.compact()
-
-
-register_level_class(BedrockLevel)

amulet/level/bedrock/_raw/__init__.py

@@ -1,5 +0,0 @@
-from ._chunk import BedrockRawChunk
-from ._dimension import BedrockRawDimension
-from ._level import BedrockRawLevel, BedrockCreateArgsV1
-from ._level_dat import BedrockLevelDAT
-from ._typing import InternalDimension

amulet/level/bedrock/_raw/_actor_counter.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from threading import RLock
-
-from amulet_nbt import LongTag
-
-if TYPE_CHECKING:
-    from ._level import BedrockRawLevel
-
-
-class ActorCounter:
-    _lock: RLock
-    _session: int
-    _count: int
-
-    def __init__(self) -> None:
-        self._lock = RLock()
-        self._session = -1
-        self._count = 0
-
-    def init(self, raw: BedrockRawLevel) -> None:
-        """Initialise the session from the level.dat file.
-        This must be run after the level has been opened so that the level.dat can be written.
-        """
-        level_dat = raw.level_dat
-        session = level_dat.compound.get_long(
-            "worldStartCount", LongTag(0xFFFFFFFF)
-        ).py_int
-        # for some reason this is a signed int stored in a signed long. Manually apply the sign correctly
-        session -= (session & 0x80000000) << 1
-
-        # create the counter object and set the session
-        self._session = session
-
-        # increment and write back so there are no conflicts
-        session -= 1
-        if session < 0:
-            session += 0x100000000
-        level_dat.compound["worldStartCount"] = LongTag(session)
-        raw.level_dat = level_dat
-
-    def next(self) -> tuple[int, int]:
-        """
-        Get the next unique session id and actor counter.
-        Session id is usually negative
-
-        :return: Tuple[session id, actor id]
-        """
-        with self._lock:
-            count = self._count
-            self._count += 1
-        return self._session, count

amulet/level/bedrock/_raw/_chunk.py

@@ -1,54 +0,0 @@
-from typing import Iterable
-from collections.abc import Mapping
-from amulet_nbt import NamedTag
-
-
-class BedrockRawChunk:
-    _keys: frozenset[bytes]
-    _chunk_data: dict[bytes, bytes]
-    _entity_actor: list[NamedTag]
-    _unknown_actor: list[NamedTag]
-
-    def __init__(
-        self,
-        *,
-        chunk_keys: Iterable[bytes] = (),
-        chunk_data: Mapping[bytes, bytes] | Iterable[tuple[bytes, bytes]] = (),
-        entity_actor: Iterable[NamedTag] = (),
-        unknown_actor: Iterable[NamedTag] = (),
-    ) -> None:
-        self._keys = frozenset(chunk_keys)
-        self._chunk_data = dict(chunk_data)
-        self._entity_actor = list(entity_actor)
-        self._unknown_actor = list(unknown_actor)
-
-    @property
-    def keys(self) -> frozenset[bytes]:
-        """All keys that make up this chunk data."""
-        return self._keys
-
-    @property
-    def chunk_data(self) -> dict[bytes, bytes]:
-        """
-        A dictionary mapping all chunk data keys that have the XXXXZZZZ[DDDD] prefix (without the prefix) to the data
-        stored in that key.
-        """
-        return self._chunk_data
-
-    @property
-    def entity_actor(self) -> list[NamedTag]:
-        """
-        A list of entity actor data.
-        UniqueID is stripped out. internalComponents is stripped out if there is no other data.
-        """
-        return self._entity_actor
-
-    @property
-    def unknown_actor(self) -> list[NamedTag]:
-        """
-        A list of actor data that does not fit in the known actor types.
-        UniqueID is stripped out.
-        internalComponents.{StorageKeyComponent}.StorageKey is replaced with a blank string.
-        All keys matching this pattern will get replaced with the real storage key when saving (at least one must exist)
-        """
-        return self._unknown_actor