amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

amulet/level/bedrock/chunk/_chunk.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import TypeVar, Self, TypeAlias, cast
+from types import UnionType
+
+import numpy
+
+from amulet.version import VersionNumber, VersionRange
+from amulet.chunk import Chunk, ComponentDataMapping
+from amulet.block import BlockStack, Block
+from amulet.biome import Biome
+
+from amulet.chunk.components.biome import (
+    Biome2DComponent,
+    Biome2DComponentData,
+    Biome3DComponent,
+    Biome3DComponentData,
+)
+from amulet.chunk.components.block import BlockComponent, BlockComponentData
+from amulet.chunk.components.block_entity import (
+    BlockEntityComponent,
+    BlockEntityComponentData,
+)
+from amulet.chunk.components.entity import EntityComponent, EntityComponentData
+from amulet.chunk.components.height_2d import Height2DComponent
+
+from .components.finalised_state import FinalisedStateComponent
+from .components.chunk_version import ChunkVersionComponent
+from .components.raw_chunk import RawChunkComponent
+
+T = TypeVar("T")
+
+
+def _get_components(
+    chunk_version: int,
+    version_range: VersionRange,
+    default_block: BlockStack,
+    default_biome: Biome,
+) -> ComponentDataMapping:
+    components: ComponentDataMapping = {}  # type: ignore
+    components[RawChunkComponent] = None
+    components[ChunkVersionComponent] = chunk_version
+    components[FinalisedStateComponent] = 2
+    components[BlockComponent] = BlockComponentData(
+        version_range, (16, 16, 16), default_block
+    )
+    components[BlockEntityComponent] = BlockEntityComponentData(version_range)
+    components[EntityComponent] = EntityComponentData(version_range)
+    if chunk_version >= 29:
+        components[Biome3DComponent] = Biome3DComponentData(
+            version_range, (16, 16, 16), default_biome
+        )
+    else:
+        components[Biome2DComponent] = Biome2DComponentData(
+            version_range, (16, 16), default_biome
+        )
+    components[Height2DComponent] = numpy.zeros((16, 16), dtype=numpy.int64)
+    return components
+
+
+class BedrockChunk0(Chunk):
+    components = frozenset(
+        _get_components(
+            0,
+            VersionRange(
+                "bedrock",
+                VersionNumber(1, 0, 0),
+                VersionNumber(1, 0, 0),
+            ),
+            BlockStack(Block("bedrock", VersionNumber(1, 0, 0), "", "")),
+            Biome("bedrock", VersionNumber(1, 0, 0), "", ""),
+        )
+    )
+
+    @classmethod
+    def new(
+        cls, max_version: VersionNumber, default_block: BlockStack, default_biome: Biome
+    ) -> Self:
+        return cls.from_component_data(
+            _get_components(
+                0,
+                VersionRange(
+                    "bedrock",
+                    VersionNumber(1, 0, 0),
+                    max_version,
+                ),
+                default_block,
+                default_biome,
+            )
+        )
+
+
+class BedrockChunk29(Chunk):
+    components = frozenset(
+        _get_components(
+            29,
+            VersionRange(
+                "bedrock",
+                VersionNumber(1, 0, 0),
+                VersionNumber(1, 0, 0),
+            ),
+            BlockStack(Block("bedrock", VersionNumber(1, 0, 0), "", "")),
+            Biome("bedrock", VersionNumber(1, 0, 0), "", ""),
+        )
+    )
+
+    @classmethod
+    def new(
+        cls, max_version: VersionNumber, default_block: BlockStack, default_biome: Biome
+    ) -> Self:
+        return cls.from_component_data(
+            _get_components(
+                29,
+                VersionRange(
+                    "bedrock",
+                    VersionNumber(1, 0, 0),
+                    max_version,
+                ),
+                default_block,
+                default_biome,
+            )
+        )
+
+
+# TODO: Improve this if python/mypy#11673 gets fixed.
+BedrockChunk: TypeAlias = cast(UnionType, BedrockChunk0 | BedrockChunk29)

amulet/level/bedrock/chunk/components/chunk_version.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+from amulet.chunk.components.abc import ChunkComponent
+
+
+class ChunkVersionComponent(ChunkComponent[int, int]):
+    storage_key = b"bcv"
+
+    @staticmethod
+    def fix_set_data(old_obj: int, new_obj: int) -> int:
+        if not isinstance(new_obj, int):
+            raise TypeError
+        return new_obj

amulet/level/bedrock/chunk/components/finalised_state.py

@@ -0,0 +1,13 @@
+from amulet.chunk.components.abc import ChunkComponent
+
+
+class FinalisedStateComponent(ChunkComponent[int, int]):
+    storage_key = b"bfs"
+
+    @staticmethod
+    def fix_set_data(old_obj: int, new_obj: int) -> int:
+        if not isinstance(new_obj, int):
+            raise TypeError
+        if new_obj < 0:
+            raise ValueError
+        return new_obj

amulet/level/bedrock/chunk/components/raw_chunk.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from amulet.level.bedrock._raw import BedrockRawChunk
+from amulet.chunk.components.abc import ChunkComponent
+
+
+class RawChunkComponent(ChunkComponent[BedrockRawChunk | None, BedrockRawChunk | None]):
+    storage_key = b"brc"
+
+    @staticmethod
+    def fix_set_data(
+        old_obj: BedrockRawChunk | None, new_obj: BedrockRawChunk | None
+    ) -> BedrockRawChunk | None:
+        if new_obj is None or isinstance(new_obj, BedrockRawChunk):
+            return new_obj
+        raise TypeError

amulet/level/java/__init__.pyi

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typing
+
+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"]
+
+def __dir__() -> typing.Any: ...
+def __getattr__(arg0: typing.Any) -> typing.Any: ...

amulet/level/java/_chunk_handle.py

@@ -0,0 +1,17 @@
+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/_chunk_handle.pyi

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.level.abc._chunk_handle
+from amulet.level.abc._chunk_handle import ChunkHandle
+from amulet.level.java.chunk import JavaChunk
+
+__all__ = ["ChunkHandle", "ChunkT", "JavaChunk", "JavaChunkHandle"]
+
+class JavaChunkHandle(amulet.level.abc._chunk_handle.ChunkHandle):
+    @staticmethod
+    def _validate_chunk(chunk: ChunkT) -> None: ...
+
+ChunkT: typing.TypeVar  # value = ~ChunkT

amulet/level/java/_dimension.py

@@ -0,0 +1,20 @@
+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/_dimension.pyi

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import amulet.level.abc._dimension
+import amulet.level.java._chunk_handle
+from amulet.level.abc._dimension import Dimension
+from amulet.level.java._chunk_handle import JavaChunkHandle
+
+__all__ = ["Dimension", "JavaChunkHandle", "JavaDimension"]
+
+class JavaDimension(amulet.level.abc._dimension.Dimension):
+    def _create_chunk_handle(
+        self, cx: int, cz: int
+    ) -> amulet.level.java._chunk_handle.JavaChunkHandle: ...

amulet/level/java/_level.py

@@ -0,0 +1,184 @@
+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/_level.pyi

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import logging as logging
+import os as os
+import typing
+from builtins import str as DimensionId
+from builtins import str as InternalDimensionId
+from builtins import str as PlatformType
+from typing import Any
+
+import amulet.level.abc._level._compactable_level
+import amulet.level.abc._level._creatable_level
+import amulet.level.abc._level._disk_level
+import amulet.level.abc._level._level
+import amulet.level.abc._level._loadable_level
+from amulet.chunk import Chunk
+from amulet.level._load import register_level_class
+from amulet.level.abc._level._compactable_level import CompactableLevel
+from amulet.level.abc._level._creatable_level import CreatableLevel
+from amulet.level.abc._level._disk_level import DiskLevel
+from amulet.level.abc._level._level import LevelOpenData
+from amulet.level.abc._level._loadable_level import LoadableLevel
+from amulet.level.abc._player_storage import PlayerStorage
+from amulet.level.java._dimension import JavaDimension
+from amulet.level.java._raw._level import JavaCreateArgsV1, JavaRawLevel
+from amulet.utils.call_spec._call_spec import (
+    BoolArg,
+    CallableArg,
+    DirectoryPathArg,
+    IntArg,
+    PositionalArgs,
+    StringArg,
+    method_spec,
+)
+from amulet.utils.weakref import DetachableWeakRef
+from amulet.version import VersionNumber
+from amulet_nbt import read_nbt
+from PIL import Image
+
+__all__ = [
+    "Any",
+    "BoolArg",
+    "CallableArg",
+    "Chunk",
+    "CompactableLevel",
+    "CreatableLevel",
+    "DetachableWeakRef",
+    "DimensionId",
+    "DirectoryPathArg",
+    "DiskLevel",
+    "Image",
+    "IntArg",
+    "InternalDimensionId",
+    "JavaCreateArgsV1",
+    "JavaDimension",
+    "JavaLevel",
+    "JavaLevelOpenData",
+    "JavaRawLevel",
+    "LevelOpenData",
+    "LoadableLevel",
+    "PlatformType",
+    "PlayerStorage",
+    "PositionalArgs",
+    "StringArg",
+    "VersionNumber",
+    "log",
+    "logging",
+    "method_spec",
+    "os",
+    "read_nbt",
+    "register_level_class",
+]
+
+class JavaLevel(
+    amulet.level.abc._level._disk_level.DiskLevel,
+    amulet.level.abc._level._creatable_level.CreatableLevel,
+    amulet.level.abc._level._loadable_level.LoadableLevel,
+    amulet.level.abc._level._compactable_level.CompactableLevel,
+):
+    __slots__: typing.ClassVar[tuple] = "_raw_level"
+    @staticmethod
+    def can_load(token: typing.Any) -> bool: ...
+    @classmethod
+    def create(cls, args: JavaCreateArgsV1) -> JavaLevel: ...
+    @classmethod
+    def load(cls, path: str) -> JavaLevel: ...
+    def _JavaLevel__init(self, raw: JavaRawLevel) -> None: ...
+    def __init__(self, _ikwiad: bool = False) -> None: ...
+    def _close(self) -> None: ...
+    def _open(self) -> None: ...
+    def compact(self) -> None: ...
+    def dimension_ids(self) -> frozenset[DimensionId]: ...
+    def get_dimension(
+        self, dimension_id: DimensionId | InternalDimensionId
+    ) -> JavaDimension: ...
+    def reload(self) -> None: ...
+    def save(self) -> None: ...
+    @property
+    def level_name(self) -> str: ...
+    @property
+    def max_game_version(self) -> VersionNumber: ...
+    @property
+    def modified_time(self) -> float: ...
+    @property
+    def native_chunk_class(self) -> Type[Chunk]: ...
+    @property
+    def path(self) -> str: ...
+    @property
+    def platform(self) -> PlatformType: ...
+    @property
+    def player(self) -> PlayerStorage: ...
+    @property
+    def raw(self) -> JavaRawLevel: ...
+    @property
+    def thumbnail(self) -> Image.Image: ...
+
+class JavaLevelOpenData(amulet.level.abc._level._level.LevelOpenData):
+    def __init__(self, level: JavaLevel) -> None: ...
+
+log: logging.Logger  # value = <Logger amulet.level.java._level (INFO)>

amulet/level/java/_raw/__init__.pyi

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import typing
+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",
+]
+
+def __dir__() -> typing.Any: ...
+def __getattr__(arg0: typing.Any) -> typing.Any: ...

amulet/level/java/_raw/_chunk.pyi

@@ -0,0 +1,23 @@
+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]: ...