amulet-core 2.0a5__cp311-cp311-macosx_10_9_universal2.whl

amulet/level/java/_raw/_level.pyi

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import copy as copy
+import glob as glob
+import json as json
+import logging as logging
+import os as os
+import shutil as shutil
+import struct as struct
+import time as time
+import typing
+from builtins import str as DimensionId
+from builtins import str as InternalDimensionId
+from dataclasses import dataclass
+from threading import RLock
+from typing import BinaryIO
+
+import amulet.level.abc._raw_level
+import amulet.selection.group
+import portalocker as portalocker
+from amulet.biome import Biome
+from amulet.block import Block, BlockStack
+from amulet.errors import LevelWriteError
+from amulet.game._game import get_game_version
+from amulet.level.abc._raw_level import RawLevel
+from amulet.level.abc._registry import IdRegistry
+from amulet.level.java._raw._data_pack.data_pack import DataPack
+from amulet.level.java._raw._data_pack.data_pack_manager import DataPackManager
+from amulet.level.java._raw._dimension import JavaRawDimension
+from amulet.level.java.anvil._dimension import AnvilDimension
+from amulet.selection.box import SelectionBox
+from amulet.selection.group import SelectionGroup
+from amulet.utils.signal._signal import Signal
+from amulet.utils.weakref import DetachableWeakRef
+from amulet.version import VersionNumber
+from amulet_nbt import (
+    CompoundTag,
+    IntTag,
+    ListTag,
+    LongTag,
+    NamedTag,
+    StringTag,
+    read_nbt,
+)
+
+__all__ = [
+    "AnvilDimension",
+    "BinaryIO",
+    "Biome",
+    "Block",
+    "BlockStack",
+    "CompoundTag",
+    "DataPack",
+    "DataPackManager",
+    "DefaultSelection",
+    "DetachableWeakRef",
+    "DimensionId",
+    "IdRegistry",
+    "IntTag",
+    "InternalDimensionId",
+    "JavaCreateArgsV1",
+    "JavaRawDimension",
+    "JavaRawLevel",
+    "JavaRawLevelOpenData",
+    "LevelWriteError",
+    "ListTag",
+    "LongTag",
+    "NamedTag",
+    "OVERWORLD",
+    "RLock",
+    "RawLevel",
+    "SelectionBox",
+    "SelectionGroup",
+    "Signal",
+    "SignalInstanceCacheName",
+    "StringTag",
+    "THE_END",
+    "THE_NETHER",
+    "VersionNumber",
+    "copy",
+    "dataclass",
+    "get_game_version",
+    "glob",
+    "json",
+    "log",
+    "logging",
+    "os",
+    "portalocker",
+    "read_nbt",
+    "shutil",
+    "struct",
+    "time",
+]
+
+class JavaCreateArgsV1:
+    """
+    A class to house call arguments to create.
+
+        If the call arguments to create need to be modified in the future a new arguments class can be created.
+        The create method can inspect which class it was given and access arguments accordingly.
+
+    """
+
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, other): ...
+    def __init__(
+        self, overwrite: bool, path: str, version: VersionNumber, level_name: str
+    ) -> None: ...
+    def __repr__(self): ...
+
+class JavaRawLevel(amulet.level.abc._raw_level.RawLevel):
+    __slots__: typing.ClassVar[tuple] = (
+        "_path",
+        "_level_dat",
+        "_data_version",
+        "_raw_open_data",
+        "_SignalCache",
+    )
+    level_name: str
+    @staticmethod
+    def closed(*args, **kwargs): ...
+    @staticmethod
+    def opened(*args, **kwargs): ...
+    @classmethod
+    def create(cls, args: JavaCreateArgsV1) -> JavaRawLevel: ...
+    @classmethod
+    def load(cls, path: str) -> JavaRawLevel: ...
+    def __init__(self, _ikwiad: bool = False) -> None: ...
+    def _find_dimensions(self) -> None: ...
+    def _get_dimension_bounds(
+        self, dimension_type_str: DimensionId
+    ) -> SelectionGroup: ...
+    def _register_dimension(
+        self, relative_dimension_path: InternalDimensionId, dimension_name: DimensionId
+    ) -> None:
+        """
+
+        Register a new dimension.
+
+        :param relative_dimension_path: The relative path to the dimension directory from the world root.
+            "" for the world root.
+        :param dimension_name: The name of the dimension shown to the user
+
+        """
+
+    def _update_data_version(self) -> None:
+        """
+        Pull the data version from the level.dat file
+        """
+
+    def close(self) -> None:
+        """
+        Close the raw level.
+        """
+
+    def compact(self) -> None:
+        """
+        Compact all region files
+        """
+
+    def dimension_ids(self) -> frozenset[DimensionId]: ...
+    def get_dimension(self, dimension_id: DimensionId) -> JavaRawDimension: ...
+    def is_open(self) -> bool: ...
+    def open(self) -> None:
+        """
+        Open the raw level.
+        """
+
+    def reload(self) -> None:
+        """
+        Reload the raw level.
+        """
+
+    @property
+    def _o(self) -> JavaRawLevelOpenData: ...
+    @property
+    def biome_id_override(self) -> IdRegistry:
+        """
+
+        A two-way map from hard coded numerical biome id <-> biome string.
+        This only stores overridden values. If the value is not present here you should check the translator.
+
+        """
+
+    @property
+    def block_id_override(self) -> IdRegistry:
+        """
+
+        A two-way map from hard coded numerical block id <-> block string.
+        This only stores overridden values. If the value is not present here you should check the translator.
+
+        """
+
+    @property
+    def data_version(self) -> VersionNumber:
+        """
+
+        The game data version that the level was last opened in.
+        This is used to determine the data format to save in.
+
+        """
+
+    @property
+    def level_dat(self) -> NamedTag:
+        """
+        Get the level.dat file for the world
+        """
+
+    @level_dat.setter
+    def level_dat(self, level_dat: NamedTag) -> None: ...
+    @property
+    def modified_time(self) -> float:
+        """
+        Unix timestamp of when the level was last modified.
+        """
+
+    @property
+    def path(self) -> str: ...
+    @property
+    def platform(self) -> str: ...
+
+class JavaRawLevelOpenData:
+    def __init__(
+        self,
+        raw_level: JavaRawLevel,
+        lock_file: BinaryIO,
+        lock_time: float,
+        data_pack: DataPackManager,
+    ) -> None: ...
+
+DefaultSelection: (
+    amulet.selection.group.SelectionGroup
+)  # value = SelectionGroup([SelectionBox((-30000000, 0, -30000000), (30000000, 256, 30000000))])
+OVERWORLD: str
+SignalInstanceCacheName: str
+THE_END: str
+THE_NETHER: str
+log: logging.Logger  # value = <Logger amulet.level.java._raw._level (INFO)>

amulet/level/java/_raw/_typing.py

@@ -0,0 +1,3 @@
+from typing import TypeAlias
+
+InternalDimensionId: TypeAlias = str

amulet/level/java/_raw/_typing.pyi

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from builtins import str as InternalDimensionId
+
+__all__ = ["InternalDimensionId"]

amulet/level/java/anvil/__init__.py

@@ -0,0 +1,2 @@
+from ._region import AnvilRegion
+from ._dimension import AnvilDimension, AnvilDimensionLayer, RawChunkType

amulet/level/java/anvil/__init__.pyi

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import types
+
+from amulet.level.java.anvil._dimension import AnvilDimension, AnvilDimensionLayer
+from amulet.level.java.anvil._region import AnvilRegion
+
+from . import _dimension, _region, _sector_manager
+
+__all__ = ["AnvilDimension", "AnvilDimensionLayer", "AnvilRegion", "RawChunkType"]
+RawChunkType: types.GenericAlias  # value = dict[str, amulet_nbt.NamedTag]

amulet/level/java/anvil/_dimension.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import TypeAlias
+import os
+from collections.abc import Iterator, Sequence
+import re
+import threading
+
+from amulet_nbt import NamedTag
+
+from amulet.utils import world_utils
+from amulet.errors import ChunkDoesNotExist
+from amulet.data_types import (
+    ChunkCoordinates,
+    RegionCoordinates,
+)
+from ._region import AnvilRegion
+
+
+RawChunkType: TypeAlias = dict[str, NamedTag]
+
+
+class AnvilDimensionLayer:
+    """A class to manage a directory of region files."""
+
+    def __init__(self, directory: str, *, mcc: bool = False):
+        self._directory = directory
+        self._regions: dict[RegionCoordinates, AnvilRegion] = {}
+        self._mcc = mcc
+        self._lock = threading.RLock()
+
+    def _region_path(self, rx: int, rz: int) -> str:
+        """Get the file path for a region file."""
+        return os.path.join(self._directory, f"r.{rx}.{rz}.mca")
+
+    def _has_region(self, rx: int, rz: int) -> bool:
+        """Does a region file exist."""
+        return os.path.isfile(self._region_path(rx, rz))
+
+    def _get_region(self, rx: int, rz: int, create: bool = False) -> AnvilRegion:
+        with self._lock:
+            if (rx, rz) in self._regions:
+                return self._regions[(rx, rz)]
+            elif create or self._has_region(rx, rz):
+                region = self._regions[(rx, rz)] = AnvilRegion(
+                    self._region_path(rx, rz), mcc=self._mcc
+                )
+                return region
+            else:
+                raise ChunkDoesNotExist
+
+    def _iter_regions(self) -> Iterator[AnvilRegion]:
+        if os.path.isdir(self._directory):
+            for region_file_name in os.listdir(self._directory):
+                try:
+                    rx, rz = AnvilRegion.get_coords(region_file_name)
+                except ValueError:
+                    continue
+                else:
+                    yield self._get_region(rx, rz)
+
+    def all_chunk_coords(self) -> Iterator[ChunkCoordinates]:
+        for region in self._iter_regions():
+            yield from region.all_coords()
+
+    def has_chunk(self, cx: int, cz: int) -> bool:
+        try:
+            region = self._get_region(
+                *world_utils.chunk_coords_to_region_coords(cx, cz)
+            )
+        except ChunkDoesNotExist:
+            return False
+        else:
+            return region.has_data(cx, cz)
+
+    def get_chunk_data(self, cx: int, cz: int) -> NamedTag:
+        """
+        Get a NamedTag of a chunk from the database.
+        Will raise ChunkDoesNotExist if the region or chunk does not exist
+        """
+        # get the region key
+        return self._get_region(
+            *world_utils.chunk_coords_to_region_coords(cx, cz)
+        ).get_data(cx, cz)
+
+    def put_chunk_data(self, cx: int, cz: int, data: NamedTag) -> None:
+        """pass data to the region file class"""
+        self._get_region(
+            *world_utils.chunk_coords_to_region_coords(cx, cz), create=True
+        ).set_data(cx, cz, data)
+
+    def delete_chunk(self, cx: int, cz: int) -> None:
+        try:
+            region = self._get_region(
+                *world_utils.chunk_coords_to_region_coords(cx, cz)
+            )
+        except ChunkDoesNotExist:
+            pass
+        else:
+            region.delete_data(cx, cz)
+
+    def compact(self) -> None:
+        """Compact all region files in this layer"""
+        for region in self._iter_regions():
+            region.compact()
+
+
+class AnvilDimension:
+    """
+    A class to manage the data for a dimension.
+    This can consist of multiple layers. Eg the region layer which contains chunk data and the entities layer which contains entities.
+    """
+
+    level_regex = re.compile(r"DIM(?P<level>-?\d+)")
+
+    def __init__(
+        self, directory: str, *, mcc: bool = False, layers: Sequence[str] = ("region",)
+    ) -> None:
+        self._directory = directory
+        self._mcc = mcc
+        self.__layers: dict[str, AnvilDimensionLayer] = {
+            layer: AnvilDimensionLayer(
+                os.path.join(self._directory, layer), mcc=self._mcc
+            )
+            for layer in layers
+        }
+        self.__default_layer = self.__layers[layers[0]]
+
+    def all_chunk_coords(self) -> Iterator[ChunkCoordinates]:
+        yield from self.__default_layer.all_chunk_coords()
+
+    def has_chunk(self, cx: int, cz: int) -> bool:
+        return self.__default_layer.has_chunk(cx, cz)
+
+    def get_chunk_data(self, cx: int, cz: int) -> RawChunkType:
+        """Get the chunk data for each layer"""
+        chunk_data = {}
+        for layer_name, layer in self.__layers.items():
+            try:
+                chunk_data[layer_name] = layer.get_chunk_data(cx, cz)
+            except ChunkDoesNotExist:
+                pass
+
+        if chunk_data:
+            return chunk_data
+        else:
+            raise ChunkDoesNotExist
+
+    def put_chunk_data(self, cx: int, cz: int, data_layers: RawChunkType) -> None:
+        """Put one or more layers of data"""
+        for layer_name, data in data_layers.items():
+            if (
+                layer_name not in self.__layers
+                and layer_name.isalpha()
+                and layer_name.islower()
+            ):
+                self.__layers[layer_name] = AnvilDimensionLayer(
+                    os.path.join(self._directory, layer_name), mcc=self._mcc
+                )
+            if layer_name in self.__layers:
+                self.__layers[layer_name].put_chunk_data(cx, cz, data)
+
+    def delete_chunk(self, cx: int, cz: int) -> None:
+        for layer in self.__layers.values():
+            layer.delete_chunk(cx, cz)
+
+    def compact(self) -> None:
+        """Compact all region files in this dimension"""
+        for layer in self.__layers.values():
+            layer.compact()

amulet/level/java/anvil/_dimension.pyi

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import os as os
+import re as re
+import threading as threading
+import types
+import typing
+from collections.abc import Iterator, Sequence
+
+from amulet.errors import ChunkDoesNotExist
+from amulet.level.java.anvil._region import AnvilRegion
+from amulet.utils import world_utils
+from amulet_nbt import NamedTag
+
+__all__ = [
+    "AnvilDimension",
+    "AnvilDimensionLayer",
+    "AnvilRegion",
+    "ChunkCoordinates",
+    "ChunkDoesNotExist",
+    "Iterator",
+    "NamedTag",
+    "RawChunkType",
+    "RegionCoordinates",
+    "Sequence",
+    "os",
+    "re",
+    "threading",
+    "world_utils",
+]
+
+class AnvilDimension:
+    """
+
+    A class to manage the data for a dimension.
+    This can consist of multiple layers. Eg the region layer which contains chunk data and the entities layer which contains entities.
+
+    """
+
+    level_regex: typing.ClassVar[
+        re.Pattern
+    ]  # value = re.compile('DIM(?P<level>-?\\d+)')
+    def __init__(
+        self,
+        directory: str,
+        *,
+        mcc: bool = False,
+        layers: typing.Sequence[str] = ("region"),
+    ) -> None: ...
+    def all_chunk_coords(self) -> typing.Iterator[ChunkCoordinates]: ...
+    def compact(self) -> None:
+        """
+        Compact all region files in this dimension
+        """
+
+    def delete_chunk(self, cx: int, cz: int) -> None: ...
+    def get_chunk_data(self, cx: int, cz: int) -> RawChunkType:
+        """
+        Get the chunk data for each layer
+        """
+
+    def has_chunk(self, cx: int, cz: int) -> bool: ...
+    def put_chunk_data(self, cx: int, cz: int, data_layers: RawChunkType) -> None:
+        """
+        Put one or more layers of data
+        """
+
+class AnvilDimensionLayer:
+    """
+    A class to manage a directory of region files.
+    """
+
+    def __init__(self, directory: str, *, mcc: bool = False): ...
+    def _get_region(self, rx: int, rz: int, create: bool = False) -> AnvilRegion: ...
+    def _has_region(self, rx: int, rz: int) -> bool:
+        """
+        Does a region file exist.
+        """
+
+    def _iter_regions(self) -> typing.Iterator[AnvilRegion]: ...
+    def _region_path(self, rx: int, rz: int) -> str:
+        """
+        Get the file path for a region file.
+        """
+
+    def all_chunk_coords(self) -> typing.Iterator[ChunkCoordinates]: ...
+    def compact(self) -> None:
+        """
+        Compact all region files in this layer
+        """
+
+    def delete_chunk(self, cx: int, cz: int) -> None: ...
+    def get_chunk_data(self, cx: int, cz: int) -> NamedTag:
+        """
+
+        Get a NamedTag of a chunk from the database.
+        Will raise ChunkDoesNotExist if the region or chunk does not exist
+
+        """
+
+    def has_chunk(self, cx: int, cz: int) -> bool: ...
+    def put_chunk_data(self, cx: int, cz: int, data: NamedTag) -> None:
+        """
+        pass data to the region file class
+        """
+
+ChunkCoordinates: types.GenericAlias  # value = tuple[int, int]
+RawChunkType: types.GenericAlias  # value = dict[str, amulet_nbt.NamedTag]
+RegionCoordinates: types.GenericAlias  # value = tuple[int, int]