amulet-core 2.0a6__cp311-cp311-win_amd64.whl → 2.0a8__cp311-cp311-win_amd64.whl

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

@@ -1,75 +0,0 @@
-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.pyi

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import types
-import typing
-from builtins import str as DimensionId
-from builtins import str as InternalDimensionId
-
-import amulet.level.abc._raw_level
-from amulet.biome import Biome
-from amulet.block import BlockStack
-from amulet.level.abc._raw_level import RawDimension, RawLevelFriend
-from amulet.level.java._raw._chunk import decode_chunk, encode_chunk
-from amulet.level.java.anvil._dimension import AnvilDimension
-from amulet.level.java.chunk import JavaChunk
-from amulet.selection.group import SelectionGroup
-
-__all__ = [
-    "AnvilDimension",
-    "Biome",
-    "BlockStack",
-    "ChunkCoordinates",
-    "DimensionId",
-    "InternalDimensionId",
-    "JavaChunk",
-    "JavaRawDimension",
-    "RawChunkType",
-    "RawDimension",
-    "RawLevelFriend",
-    "SelectionGroup",
-    "decode_chunk",
-    "encode_chunk",
-]
-
-class JavaRawDimension(
-    amulet.level.abc._raw_level.RawLevelFriend, amulet.level.abc._raw_level.RawDimension
-):
-    def __init__(
-        self,
-        raw_level_ref: typing.Callable[[], JavaRawLevel | None],
-        anvil_dimension: AnvilDimension,
-        relative_path: InternalDimensionId,
-        dimension_id: DimensionId,
-        bounds: SelectionGroup,
-        default_block: BlockStack,
-        default_biome: Biome,
-    ) -> None: ...
-    def all_chunk_coords(self) -> typing.Iterable[ChunkCoordinates]: ...
-    def bounds(self) -> SelectionGroup: ...
-    def compact(self) -> None:
-        """
-        Compact all region files
-        """
-
-    def default_biome(self) -> Biome: ...
-    def default_block(self) -> BlockStack: ...
-    def delete_chunk(self, cx: int, cz: int) -> None: ...
-    def get_raw_chunk(self, cx: int, cz: int) -> RawChunkType: ...
-    def has_chunk(self, cx: int, cz: int) -> bool: ...
-    def native_chunk_to_raw_chunk(
-        self, chunk: JavaChunk, cx: int, cz: int
-    ) -> RawChunkType: ...
-    def raw_chunk_to_native_chunk(
-        self, raw_chunk: RawChunkType, cx: int, cz: int
-    ) -> JavaChunk: ...
-    def set_raw_chunk(self, cx: int, cz: int, chunk: RawChunkType) -> None: ...
-    @property
-    def dimension_id(self) -> DimensionId: ...
-    @property
-    def relative_path(self) -> InternalDimensionId: ...
-
-ChunkCoordinates: types.GenericAlias  # value = tuple[int, int]
-RawChunkType: types.GenericAlias  # value = dict[str, amulet_nbt.NamedTag]

amulet/level/java/_raw/_level.pyi

@@ -1,238 +0,0 @@
-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.pyi

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

amulet/level/java/anvil/__init__.pyi

@@ -1,11 +0,0 @@
-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.pyi

@@ -1,109 +0,0 @@
-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]

amulet/level/java/anvil/_region.pyi

@@ -1,197 +0,0 @@
-from __future__ import annotations
-
-import enum
-import gzip as gzip
-import logging as logging
-import os as os
-import re as re
-import struct as struct
-import threading as threading
-import time as time
-import types
-import typing
-import zlib as zlib
-from collections.abc import Iterator
-from enum import IntEnum
-from typing import BinaryIO
-
-import _struct
-import amulet.level.java.anvil._sector_manager
-import numpy as numpy
-from amulet.errors import ChunkDoesNotExist, ChunkLoadError
-from amulet.level.java.anvil._sector_manager import Sector, SectorManager
-from amulet_nbt import NamedTag, read_nbt
-from lz4 import block as lz4_block
-
-__all__ = [
-    "AnvilRegion",
-    "BinaryIO",
-    "COMPRESSION_METHOD_LZ4",
-    "COMPRESSION_METHOD_RAW",
-    "ChunkCoordinates",
-    "ChunkDoesNotExist",
-    "ChunkLoadError",
-    "HeaderSector",
-    "IntEnum",
-    "Iterator",
-    "LZ4_HEADER",
-    "LZ4_MAGIC",
-    "MaxRegionSize",
-    "NamedTag",
-    "RegionFileVersion",
-    "Sector",
-    "SectorManager",
-    "SectorSize",
-    "gzip",
-    "log",
-    "logging",
-    "lz4_block",
-    "numpy",
-    "os",
-    "re",
-    "read_nbt",
-    "struct",
-    "threading",
-    "time",
-    "zlib",
-]
-
-class AnvilRegion:
-    """
-
-    A class to read and write Minecraft Java Edition Region files.
-    Only one class should exist per region file at any given time otherwise bad things may happen.
-
-    """
-
-    __slots__: typing.ClassVar[tuple] = (
-        "_path",
-        "_rx",
-        "_rz",
-        "_mcc",
-        "_sector_manager",
-        "_chunk_locations",
-        "_lock",
-    )
-    region_regex: typing.ClassVar[
-        re.Pattern
-    ]  # value = re.compile('r\\.(?P<rx>-?\\d+)\\.(?P<rz>-?\\d+)\\.mca')
-    @classmethod
-    def get_coords(cls, file_path: str) -> tuple[int, int]:
-        """
-        Parse a region file path to get the region coordinates.
-        """
-
-    def __init__(self, file_path: str, *, mcc: bool = False) -> None:
-        """
-
-        A class wrapper for a region file
-        :param file_path: The file path of the region file
-        :param create: bool - if true will create the region from scratch. If false will try loading from disk
-
-        """
-
-    def _load(self) -> None:
-        """
-        Load region metadata. The lock must be acquired when calling this.
-        """
-
-    def _write_data(self, cx: int, cz: int, data: bytes | None) -> None: ...
-    def all_coords(self) -> typing.Iterator[ChunkCoordinates]:
-        """
-        An iterable of chunk coordinates in world space.
-        """
-
-    def compact(self) -> None:
-        """
-        Compact the region file.
-                This moves all entries to the front of the file and deletes any unused space.
-        """
-
-    def delete_data(self, cx: int, cz: int) -> None:
-        """
-        Delete the data from the region file.
-        """
-
-    def get_data(self, cx: int, cz: int) -> NamedTag: ...
-    def get_mcc_path(self, cx: int, cz: int) -> str:
-        """
-        Get the mcc path. Coordinates are world chunk coordinates.
-        """
-
-    def has_data(self, cx: int, cz: int) -> bool:
-        """
-        Does the chunk exists. Coords are in world space.
-        """
-
-    def set_data(self, cx: int, cz: int, data: NamedTag) -> None:
-        """
-        Write the data to the region file.
-        """
-
-    @property
-    def path(self) -> str:
-        """
-        The file path to the region file.
-        """
-
-    @property
-    def rx(self) -> int:
-        """
-        The region x coordinate.
-        """
-
-    @property
-    def rz(self) -> int:
-        """
-        The region z coordinate.
-        """
-
-class RegionFileVersion(enum.IntEnum):
-    VERSION_DEFLATE: typing.ClassVar[
-        RegionFileVersion
-    ]  # value = <RegionFileVersion.VERSION_DEFLATE: 2>
-    VERSION_GZIP: typing.ClassVar[
-        RegionFileVersion
-    ]  # value = <RegionFileVersion.VERSION_GZIP: 1>
-    VERSION_LZ4: typing.ClassVar[
-        RegionFileVersion
-    ]  # value = <RegionFileVersion.VERSION_LZ4: 4>
-    VERSION_NONE: typing.ClassVar[
-        RegionFileVersion
-    ]  # value = <RegionFileVersion.VERSION_NONE: 3>
-    @classmethod
-    def __new__(cls, value): ...
-    def __format__(self, format_spec):
-        """
-        Convert to a string according to format_spec.
-        """
-
-def _compress(tag: NamedTag) -> bytes:
-    """
-    Convert an NBTFile into a compressed bytes object
-    """
-
-def _decompress(data: bytes) -> NamedTag:
-    """
-    Convert a bytes object into an NBTFile
-    """
-
-def _decompress_lz4(data: bytes) -> bytes:
-    """
-    The LZ4 compression format is a sequence of LZ4 blocks with some header data.
-    """
-
-def _sanitise_file(handler: BinaryIO) -> None: ...
-
-COMPRESSION_METHOD_LZ4: int = 32
-COMPRESSION_METHOD_RAW: int = 16
-ChunkCoordinates: types.GenericAlias  # value = tuple[int, int]
-HeaderSector: (
-    amulet.level.java.anvil._sector_manager.Sector
-)  # value = Sector(start=0, stop=8192)
-LZ4_HEADER: _struct.Struct  # value = <_struct.Struct object>
-LZ4_MAGIC: bytes  # value = b'LZ4Block'
-MaxRegionSize: int = 1044480
-SectorSize: int = 4096
-log: logging.Logger  # value = <Logger amulet.level.java.anvil._region (INFO)>