amulet-core 2.0a3__cp312-cp312-win_amd64.whl

amulet/game/translate/_translator.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+from typing import Callable, Union, Sequence, TypeVar, Type, Any, TYPE_CHECKING
+import json
+import glob
+import os
+from concurrent.futures import ThreadPoolExecutor
+
+from amulet_nbt import (
+    read_nbt,
+    read_snbt,
+    NamedTag,
+    ListTag,
+    CompoundTag,
+    AnyNBT,
+)
+
+from amulet.block import Block
+from amulet.block_entity import BlockEntity
+from amulet.entity import Entity
+from amulet.data_types import BlockCoordinates
+from amulet.version import VersionNumber
+
+from ._functions import (
+    AbstractBaseTranslationFunction,
+    SrcData,
+    SrcDataExtra,
+    StateData,
+    DstData,
+)
+from ._functions.abc import translation_function_from_json
+from ._functions._typing import NBTPath
+
+if TYPE_CHECKING:
+    from amulet.game.abc import GameVersion, BlockSpec
+
+
+# These classes exist to do some pre-translation and post-translation processing.
+# They also store the constant data so that it doesn't need to be passed in each time.
+# They don't do any caching
+
+
+def create_nbt(
+    outer_name: str,
+    outer_type: type[ListTag] | type[CompoundTag],
+    nbt_list: Sequence[
+        tuple[
+            str,
+            type[ListTag] | type[CompoundTag],
+            NBTPath,
+            Union[str, int],
+            AnyNBT,
+        ]
+    ],
+    default_template: str | None = None,
+) -> NamedTag:
+    nbt_object: AnyNBT
+    if default_template is None:
+        nbt_object = outer_type()
+    else:
+        nbt_object = read_snbt(default_template)
+
+    for nbt_entry in nbt_list:
+        (
+            element_outer_name,
+            element_outer_type,
+            element_nbt_path,
+            element_data_path,
+            element_data,
+        ) = nbt_entry
+        if outer_name == element_outer_name and issubclass(
+            outer_type, element_outer_type
+        ):
+            nbt_temp: AnyNBT = nbt_object
+            for path, nbt_type in element_nbt_path:
+                # if the nested NBT object does not exist then create it
+                if isinstance(nbt_temp, CompoundTag):
+                    assert isinstance(path, str)
+                    if path not in nbt_temp or not isinstance(nbt_temp[path], nbt_type):
+                        nbt_temp[path] = nbt_type()
+                    nbt_temp = nbt_temp[path]
+                elif isinstance(nbt_temp, ListTag):
+                    assert isinstance(path, int)
+                    # if the list is a different type to nbt_type replace it with nbt_type
+                    if len(nbt_temp) > 0 and not isinstance(nbt_temp[0], nbt_type):
+                        raise RuntimeError("ListTag elements are the wrong type")
+
+                    for _ in range(path + 1 - len(nbt_temp)):
+                        # pad out the list to the length of the index
+                        nbt_temp.append(nbt_type())
+                    # we now should have a ListTag of the same type as nbt_type and length as path
+                    nbt_temp = nbt_temp[path]
+                else:
+                    raise RuntimeError
+
+            if isinstance(nbt_temp, CompoundTag):
+                assert isinstance(element_data_path, str)
+                nbt_temp[element_data_path] = element_data
+
+            elif isinstance(nbt_temp, ListTag):
+                assert isinstance(element_data_path, int)
+                # if the list is a different type to data replace it with type(data)
+                if (
+                    len(nbt_temp) > 0
+                    and nbt_temp[0].list_data_type != element_data.tag_id
+                ):
+                    raise RuntimeError("ListTag elements are the wrong type")
+
+                for _ in range(element_data_path + 1 - len(nbt_temp)):
+                    # pad out the list to the length of the index
+                    nbt_temp.append(element_data.__class__())
+                # we now should have a ListTag of the same type as nbt_type and length as data_path
+                nbt_temp[element_data_path] = element_data
+
+            # TODO:
+            # elif isinstance(nbt_temp, ByteArrayTag) and isinstance(data, ByteTag):
+            # 	# pad to the length of data_path if less than the current length
+            # 	# nbt_temp[data_path] = data.value
+            # elif isinstance(nbt_temp, IntArrayTag) and isinstance(data, IntTag):
+            # elif isinstance(nbt_temp, LongArrayTag) and isinstance(data, LongTag):
+
+    return NamedTag(nbt_object, outer_name)
+
+
+class BlockToUniversalTranslator:
+    # Class variables
+    _instances: dict[BlockToUniversalTranslator, BlockToUniversalTranslator] = {}
+
+    # Instance variables
+    _src_spec: BlockSpec
+    _translation: AbstractBaseTranslationFunction
+    _universal_version: GameVersion
+    _hash: int | None
+
+    def __new__(
+        cls,
+        src_spec: BlockSpec,
+        translation: AbstractBaseTranslationFunction,
+        universal_version: GameVersion,
+    ) -> BlockToUniversalTranslator:
+        self = super().__new__(cls)
+        self._src_spec = src_spec
+        self._translation = translation
+        self._universal_version = universal_version
+        self._hash = None
+        return cls._instances.setdefault(self, self)
+
+    def __reduce__(self) -> Any:
+        return BlockToUniversalTranslator, (
+            self._src_spec,
+            self._translation,
+            self._universal_version,
+        )
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(
+                (self._src_spec, self._translation, self._universal_version)
+            )
+        return self._hash
+
+    def run(
+        self,
+        block: Block,
+        block_entity: BlockEntity | None,
+        extra: (
+            tuple[
+                BlockCoordinates,
+                Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]],
+            ]
+            | None
+        ),
+    ) -> tuple[Block, BlockEntity | None, bool, bool]:
+        if extra is None:
+            src_extra = None
+        else:
+            coords, get_block = extra
+            src_extra = SrcDataExtra(coords, get_block)
+
+        block_entity_nbt = None if block_entity is None else block_entity.nbt
+
+        if self._src_spec.nbt is not None and block_entity_nbt is None:
+            # There should be a block entity
+            if src_extra is not None:
+                # Load it from the level
+                block_entity = src_extra.get_block_callback((0, 0, 0))[1]
+                if block_entity is not None:
+                    block_entity_nbt = block_entity.nbt
+            if block_entity_nbt is None:
+                # If it is still None then load it from the specification
+                block_entity_nbt = read_nbt(self._src_spec.nbt.snbt)
+
+        src = SrcData(block, block_entity_nbt, src_extra)
+        state = StateData()
+        dst = DstData()
+        self._translation.run(src, state, dst)
+
+        assert dst.cls is Block
+        assert dst.resource_id is not None
+        namespace, base_name = dst.resource_id
+
+        dst_spec = self._universal_version.block.get_specification(namespace, base_name)
+        properties = {k: v.default for k, v in dst_spec.properties.items()}
+        properties.update(dst.properties)
+
+        dst_block = Block(
+            "universal", VersionNumber(1), namespace, base_name, properties
+        )
+
+        if dst_spec.nbt is None:
+            dst_block_entity = None
+        else:
+            dst_block_entity = BlockEntity(
+                "universal",
+                VersionNumber(1),
+                dst_spec.nbt.namespace,
+                dst_spec.nbt.base_name,
+                create_nbt(
+                    "",
+                    CompoundTag,
+                    dst.nbt,
+                    dst_spec.nbt.snbt,
+                ),
+            )
+
+        return dst_block, dst_block_entity, dst.extra_needed, dst.cacheable
+
+
+class BlockFromUniversalTranslator:
+    # Class variables
+    _instances: dict[BlockFromUniversalTranslator, BlockFromUniversalTranslator] = {}
+
+    # Instance variables
+    _src_spec: BlockSpec
+    _translation: AbstractBaseTranslationFunction
+    _target_version: GameVersion
+    _hash: int | None
+
+    def __new__(
+        cls,
+        src_spec: BlockSpec,
+        translation: AbstractBaseTranslationFunction,
+        target_version: GameVersion,
+    ) -> BlockFromUniversalTranslator:
+        self = super().__new__(cls)
+        self._src_spec = src_spec
+        self._translation = translation
+        self._target_version = target_version
+        self._hash = None
+        return cls._instances.setdefault(self, self)
+
+    def __reduce__(self) -> Any:
+        return BlockFromUniversalTranslator, (
+            self._src_spec,
+            self._translation,
+            self._target_version,
+        )
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash((self._src_spec, self._translation, self._target_version))
+        return self._hash
+
+    def run(
+        self,
+        target_platform: str,
+        target_version: VersionNumber,
+        block: Block,
+        block_entity: BlockEntity | None,
+        extra: (
+            tuple[
+                BlockCoordinates,
+                Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]],
+            ]
+            | None
+        ),
+    ) -> tuple[Block, BlockEntity | None, bool, bool] | tuple[Entity, None, bool, bool]:
+        if extra is None:
+            src_extra = None
+        else:
+            coords, get_block = extra
+            src_extra = SrcDataExtra(coords, get_block)
+
+        block_entity_nbt = None if block_entity is None else block_entity.nbt
+
+        if self._src_spec.nbt is not None and block_entity_nbt is None:
+            # There should be a block entity
+            if src_extra is not None:
+                # Load it from the level
+                block_entity = src_extra.get_block_callback((0, 0, 0))[1]
+                if block_entity is not None:
+                    block_entity_nbt = block_entity.nbt
+            if block_entity_nbt is None:
+                # If it is still None then load it from the specification
+                block_entity_nbt = read_nbt(self._src_spec.nbt.snbt)
+
+        src = SrcData(block, block_entity_nbt, src_extra)
+        state = StateData()
+        dst = DstData()
+        self._translation.run(src, state, dst)
+
+        if dst.cls is Block:
+            assert dst.resource_id is not None
+            namespace, base_name = dst.resource_id
+
+            dst_spec = self._target_version.block.get_specification(
+                namespace, base_name
+            )
+            properties = {k: v.default for k, v in dst_spec.properties.items()}
+            properties.update(dst.properties)
+
+            dst_block = Block(
+                target_platform, target_version, namespace, base_name, properties
+            )
+
+            if dst_spec.nbt is None:
+                dst_block_entity = None
+            else:
+                dst_block_entity = BlockEntity(
+                    target_platform,
+                    target_version,
+                    dst_spec.nbt.namespace,
+                    dst_spec.nbt.base_name,
+                    create_nbt(
+                        "",
+                        CompoundTag,
+                        dst.nbt,
+                        dst_spec.nbt.snbt,
+                    ),
+                )
+
+            return dst_block, dst_block_entity, dst.extra_needed, dst.cacheable
+
+        elif dst.cls is Entity:
+            assert dst.resource_id is not None
+            namespace, base_name = dst.resource_id
+
+            # dst_spec = self._target_version.block.get_specification(
+            #     namespace, base_name
+            # )
+
+            dst_entity = Entity(
+                target_platform,
+                target_version,
+                namespace,
+                base_name,
+                0.0,
+                0.0,
+                0.0,
+                create_nbt(
+                    "",
+                    CompoundTag,
+                    dst.nbt,
+                    # dst_spec.nbt.snbt,
+                ),
+            )
+
+            return dst_entity, None, dst.extra_needed, dst.cacheable
+
+        else:
+            raise RuntimeError
+
+
+TranslationClsT = TypeVar(
+    "TranslationClsT", BlockToUniversalTranslator, BlockFromUniversalTranslator
+)
+
+
+def _read_file(path: str) -> str:
+    with open(path) as f:
+        return f.read()
+
+
+def load_json_block_translations(
+    version_path: str,
+    block_format: str,
+    direction: str,
+    translation_cls: Type[TranslationClsT],
+    get_src_spec: Callable[[str, str], BlockSpec],
+    target_version: GameVersion,
+) -> dict[tuple[str, str], TranslationClsT]:
+    translations = dict[tuple[str, str], TranslationClsT]()
+    paths = glob.glob(
+        os.path.join(
+            glob.escape(version_path),
+            "block",
+            block_format,
+            direction,
+            "*",
+            "*",
+            "*.json",
+        )
+    )
+    with ThreadPoolExecutor() as e:
+        for file_path, data in zip(paths, e.map(_read_file, paths)):
+            *_, namespace, _, base_name = os.path.splitext(os.path.normpath(file_path))[
+                0
+            ].split(os.sep)
+            translations[(namespace, base_name)] = translation_cls(
+                get_src_spec(namespace, base_name),
+                translation_function_from_json(json.loads(data)),
+                target_version,
+            )
+    return translations
+
+
+class EntityToUniversalTranslator:
+    def run(
+        self,
+        entity: Entity,
+        extra: (
+            tuple[
+                BlockCoordinates,
+                Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]],
+            ]
+            | None
+        ),
+    ) -> tuple[Block, BlockEntity | None, bool, bool]:
+        raise NotImplementedError
+
+
+class EntityFromUniversalTranslator:
+    def run(
+        self,
+        entity: Entity | None,
+        extra: (
+            tuple[
+                BlockCoordinates,
+                Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]],
+            ]
+            | None
+        ),
+    ) -> tuple[Block, BlockEntity | None, bool] | tuple[Entity, None, bool]:
+        raise NotImplementedError

amulet/item.py

@@ -0,0 +1,75 @@
+# from amulet_nbt import CompoundTag, StringTag
+#
+#
+# class Item(CompoundTag):
+#     """
+#     {
+#         "namespace": StringTag,
+#         "base_name": StringTag,
+#         "metadata": CompoundTag
+#     }
+#     """
+#
+#     def __init__(self, namespace: str, base_name: str, metadata: dict = None) -> None:
+#         super().__init__(
+#             {
+#                 "namespace": StringTag(namespace),
+#                 "base_name": StringTag(base_name),
+#                 "metadata": CompoundTag(metadata or {}),
+#             }
+#         )
+#
+#     @property
+#     def namespace(self) -> str:
+#         return self.get_string("namespace").py_str
+#
+#     @property
+#     def base_name(self) -> str:
+#         return self.get_string("base_name").py_str
+#
+#     @property
+#     def metadata(self) -> CompoundTag:
+#         return self.get_compound("metadata")
+#
+#
+# class BlockItem(CompoundTag):
+#     """
+#     {
+#         "namespace": StringTag,
+#         "base_name": StringTag,
+#         "properties": CompoundTag
+#         "metadata": CompoundTag
+#     }
+#     """
+#
+#     def __init__(
+#         self,
+#         namespace: str,
+#         base_name: str,
+#         properties: dict = None,
+#         metadata: dict = None,
+#     ):
+#         super().__init__(
+#             {
+#                 "namespace": StringTag(namespace),
+#                 "base_name": StringTag(base_name),
+#                 "properties": CompoundTag(properties or {}),
+#                 "metadata": CompoundTag(metadata or {}),
+#             }
+#         )
+#
+#     @property
+#     def namespace(self) -> str:
+#         return self.get_string("namespace").py_str
+#
+#     @property
+#     def base_name(self) -> str:
+#         return self.get_string("base_name").py_str
+#
+#     @property
+#     def properties(self) -> CompoundTag:
+#         return self.get_compound("properties")
+#
+#     @property
+#     def metadata(self) -> CompoundTag:
+#         return self.get_compound("metadata")

amulet/level/__init__.pyi

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import typing
+
+from amulet.level._load import (
+    NoValidLevel,
+    get_level,
+    register_level_class,
+    unregister_level_class,
+)
+from amulet.level.abc._level._level import Level
+from amulet.level.java._level import JavaLevel
+
+from . import java
+
+__all__ = [
+    "JavaLevel",
+    "Level",
+    "NoValidLevel",
+    "get_level",
+    "java",
+    "register_level_class",
+    "unregister_level_class",
+]
+
+def __dir__() -> typing.Any: ...
+def __getattr__(arg0: typing.Any) -> typing.Any: ...

amulet/level/_load.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Type, Any
+import logging
+from inspect import isclass
+from threading import Lock
+from weakref import WeakValueDictionary
+
+from amulet.level.abc import LoadableLevel
+
+
+log = logging.getLogger(__name__)
+
+
+_level_classes = set[Type[LoadableLevel]]()
+_levels = WeakValueDictionary[Any, LoadableLevel]()
+_lock = Lock()
+
+
+def _check_loadable_level(cls: Any) -> None:
+    if not (isclass(cls) and issubclass(cls, LoadableLevel)):
+        raise TypeError(
+            "cls must be a subclass of amulet.level.abc.Level and amulet.level.abc.LoadableLevel"
+        )
+
+
+def register_level_class(cls: Type[LoadableLevel]) -> None:
+    """Add a level class to be considered when getting a level.
+
+    :param cls: The Level subclass to register.
+    :return:
+    """
+    _check_loadable_level(cls)
+    with _lock:
+        _level_classes.add(cls)
+
+
+def unregister_level_class(cls: Type[LoadableLevel]) -> None:
+    """Remove a level class from consideration when getting a level.
+
+    Note that any instances of the class will remain.
+
+    :param cls: The Level subclass to unregister.
+    """
+    _check_loadable_level(cls)
+    with _lock:
+        _level_classes.discard(cls)
+
+
+class NoValidLevel(Exception):
+    """An error thrown if no level could load the token."""
+
+    pass
+
+
+def get_level(token: Any) -> LoadableLevel:
+    """Get the level for the given token.
+
+    If a level object already exists for this token then that will be returned.
+    This will return a subclass of Level specialised for that level type.
+    Note that the returned level may or may not be open.
+    The level will automatically close itself when the last reference is lost so you must hold a strong reference to it.
+
+    :param token: The token to load. This may be a file/directory path or some other token.
+    :return: The level instance.
+    :raises:
+        NoValidLevel: If no level could load the token.
+
+        Exception: Other errors.
+    """
+    level: None | LoadableLevel
+    with _lock:
+        # Find the level to load the token
+        cls = next((cls for cls in _level_classes if cls.can_load(token)), None)
+
+        if cls is None:
+            # If no level could load the token then raise
+            raise NoValidLevel(f"Could not load {token}")
+
+        try:
+            # Try and get a cached instance of the level
+            level = _levels.get(token)
+            if level is not None:
+                # If there is a cached instance then return it
+                return level
+        except TypeError:
+            # If the token is not hashable
+            pass
+
+        # Load the level
+        level = cls.load(token)
+
+        try:
+            # Cache the level
+            _levels[token] = level
+        except TypeError:
+            # Token may not be hashable
+            pass
+
+        return level

amulet/level/abc/__init__.py

@@ -0,0 +1,12 @@
+from ._level import *
+from ._chunk_handle import ChunkHandle
+from ._player_storage import PlayerStorage
+from ._raw_level import (
+    RawLevel,
+    RawLevelFriend,
+    RawLevelPlayerComponent,
+    RawLevelBufferedComponent,
+    RawDimension,
+)
+from ._dimension import Dimension
+from ._registry import IdRegistry