amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

amulet/game/translate/_functions/_typing.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Union, Type, TypeAlias
+from collections.abc import Iterable
+
+from amulet_nbt import (
+    ByteTag,
+    ShortTag,
+    IntTag,
+    LongTag,
+    FloatTag,
+    DoubleTag,
+    StringTag,
+    ListTag,
+    CompoundTag,
+    ByteArrayTag,
+    IntArrayTag,
+    LongArrayTag,
+)
+
+NBTTagT: TypeAlias = Union[
+    ByteTag,
+    ShortTag,
+    IntTag,
+    LongTag,
+    FloatTag,
+    DoubleTag,
+    ByteArrayTag,
+    StringTag,
+    ListTag,
+    CompoundTag,
+    IntArrayTag,
+    LongArrayTag,
+]
+
+NBTTagClasses = (
+    ByteTag,
+    ShortTag,
+    IntTag,
+    LongTag,
+    FloatTag,
+    DoubleTag,
+    ByteArrayTag,
+    StringTag,
+    ListTag,
+    CompoundTag,
+    IntArrayTag,
+    LongArrayTag,
+)
+
+NBTTagClsT: TypeAlias = Union[
+    Type[ByteTag],
+    Type[ShortTag],
+    Type[IntTag],
+    Type[LongTag],
+    Type[FloatTag],
+    Type[DoubleTag],
+    Type[ByteArrayTag],
+    Type[StringTag],
+    Type[ListTag],
+    Type[CompoundTag],
+    Type[IntArrayTag],
+    Type[LongArrayTag],
+]
+
+StrToNBTCls = {
+    "byte": ByteTag,
+    "short": ShortTag,
+    "int": IntTag,
+    "long": LongTag,
+    "float": FloatTag,
+    "double": DoubleTag,
+    "byte_array": ByteArrayTag,
+    "string": StringTag,
+    "list": ListTag,
+    "compound": CompoundTag,
+    "int_array": IntArrayTag,
+    "long_array": LongArrayTag,
+}
+
+NBTClsToStr = {
+    ByteTag: "byte",
+    ShortTag: "short",
+    IntTag: "int",
+    LongTag: "long",
+    FloatTag: "float",
+    DoubleTag: "double",
+    ByteArrayTag: "byte_array",
+    StringTag: "string",
+    ListTag: "list",
+    CompoundTag: "compound",
+    IntArrayTag: "int_array",
+    LongArrayTag: "long_array",
+}
+
+
+NBTPathElement: TypeAlias = tuple[str | int, NBTTagClsT]
+NBTPath: TypeAlias = tuple[NBTPathElement, ...]

amulet/game/translate/_functions/abc.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, cast, Self, ClassVar
+from abc import ABC, abstractmethod, ABCMeta
+
+from amulet_nbt import (
+    read_snbt,
+    NamedTag,
+    CompoundTag,
+    ListTag,
+)
+
+from amulet.block import PropertyValueType
+from amulet.game.abc import JSONInterface, JSONCompatible
+from ._state import SrcData, StateData, DstData
+from ._typing import NBTPath, NBTTagT
+
+
+def immutable_from_snbt(snbt: str) -> PropertyValueType:
+    val = read_snbt(snbt)
+    assert isinstance(val, PropertyValueType)
+    return val
+
+
+def follow_nbt_path(
+    nbt: NamedTag, nbt_path: tuple[str, type[CompoundTag] | type[ListTag], NBTPath]
+) -> NBTTagT | None:
+    outer_name, outer_type, path = nbt_path
+    if nbt.name != outer_name or not isinstance(nbt.tag, outer_type):
+        return None
+    tag = nbt.tag
+    for key, tag_cls in path:
+        if isinstance(key, int) and isinstance(tag, ListTag) and key < len(tag):
+            tag = tag[key]
+        elif isinstance(key, str) and isinstance(tag, CompoundTag) and key in tag:
+            tag = tag[key]
+        else:
+            return None
+        if not isinstance(tag, tag_cls):
+            return None
+    return cast(NBTTagT | None, tag)
+
+
+def translation_function_from_json(
+    data: JSONCompatible,
+) -> AbstractBaseTranslationFunction:
+    if isinstance(data, list):
+        func_cls = _translation_functions["sequence"]
+        return func_cls.from_json(data)
+    elif isinstance(data, dict):
+        function_name = data["function"]
+        assert isinstance(function_name, str)
+        func_cls = _translation_functions[function_name]
+        return func_cls.from_json(data)
+    else:
+        raise TypeError
+
+
+_translation_functions: dict[str, type[AbstractBaseTranslationFunction]] = {}
+
+
+class Data(Protocol):
+    def __hash__(self) -> int: ...
+
+    def __eq__(self, other: Any) -> bool: ...
+
+
+class CacheMeta(ABCMeta):
+    """This modifies the construction of the instance to always return a cached instance, if one exists."""
+
+    def __call__(cls: type[AbstractBaseTranslationFunction], *args: Any, **kwargs: Any) -> AbstractBaseTranslationFunction:  # type: ignore
+        obj = cls.__new__(cls)
+        obj.__init__(*args, **kwargs)  # type: ignore
+        return cls._instances.setdefault(obj, obj)
+
+
+class AbstractBaseTranslationFunction(JSONInterface, metaclass=CacheMeta):
+    Name: ClassVar[str] = ""
+    _instances: ClassVar[dict[Self, Self]]
+    _hash: int | None
+
+    def __init__(self) -> None:
+        self._hash = None
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        if cls.Name == "":
+            raise RuntimeError(f"Name attribute has not been set for {cls}")
+        if cls.Name in _translation_functions:
+            raise RuntimeError(
+                f"A translation function with name {cls.Name} already exists."
+            )
+        _translation_functions[cls.Name] = cls
+
+    @abstractmethod
+    def __reduce__(self) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _data(self) -> Data:
+        raise NotImplementedError
+
+    def __bool__(self) -> bool:
+        return True
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(self._data())
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and self._data() == other._data()
+
+    @abstractmethod
+    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
+        """Run the translation function"""
+        raise NotImplementedError

amulet/game/translate/_functions/carry_nbt.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from typing import Self, Any
+
+from amulet_nbt import CompoundTag, ListTag, AbstractBaseNumericTag
+
+from .abc import (
+    AbstractBaseTranslationFunction,
+    Data,
+    follow_nbt_path,
+)
+from amulet.game.abc import JSONCompatible, JSONDict
+from ._typing import NBTTagClsT, NBTClsToStr, StrToNBTCls, NBTPath
+from ._state import SrcData, StateData, DstData
+
+
+class CarryNBT(AbstractBaseTranslationFunction):
+    # Class variables
+    Name = "carry_nbt"
+    _instances = {}
+
+    # Instance variables
+    _outer_name: str
+    _outer_type: type[CompoundTag] | type[ListTag]
+    _path: NBTPath | None
+    _key: str | int | None
+    _tag_cls: NBTTagClsT | None
+
+    def __init__(
+        self,
+        outer_name: str = "",
+        outer_type: type[CompoundTag] | type[ListTag] = CompoundTag,
+        path: NBTPath | None = None,
+        key: str | int | None = None,
+        tag_cls: NBTTagClsT | None = None,
+    ) -> None:
+        super().__init__()
+        self._outer_name = outer_name
+        self._outer_type = outer_type
+        self._path = path
+        self._key = key
+        self._tag_cls = tag_cls
+
+    def __reduce__(self) -> Any:
+        return CarryNBT, (
+            self._outer_name,
+            self._outer_type,
+            self._path,
+            self._key,
+            self._tag_cls,
+        )
+
+    def _data(self) -> Data:
+        return (
+            self._outer_name,
+            self._outer_type,
+            self._path,
+            self._key,
+            self._tag_cls,
+        )
+
+    @classmethod
+    def from_json(cls, data: JSONCompatible) -> Self:
+        assert isinstance(data, dict)
+        assert data.get("function") == "carry_nbt"
+        options = data.get("options", {})
+        assert isinstance(options, dict)
+        outer_name = options.get("outer_name", "")
+        assert isinstance(outer_name, str)
+        outer_type_name = options.get("outer_type", "compound")
+        outer_type: type[CompoundTag] | type[ListTag]
+        if outer_type_name == "compound":
+            outer_type = CompoundTag
+        elif outer_type_name == "list":
+            outer_type = ListTag
+        else:
+            raise RuntimeError
+        assert isinstance(outer_type_name, str)
+        path: NBTPath | None
+        if "path" in options:
+            raw_path = options["path"]
+            assert isinstance(raw_path, list)
+            path_ = []
+            for item in raw_path:
+                assert isinstance(item, list) and len(item) == 2
+                key, cls_name = item
+                assert isinstance(key, str | int)
+                nbt_cls: type[CompoundTag] | type[ListTag]
+                if cls_name == "compound":
+                    nbt_cls = CompoundTag
+                elif cls_name == "list":
+                    nbt_cls = ListTag
+                else:
+                    raise RuntimeError
+                path_.append((key, nbt_cls))
+            path = NBTPath(path_)
+        else:
+            path = None
+        key = options.get("key", None)
+        if key is not None:
+            assert isinstance(key, str | int)
+        cls_name = options.get("type", None)
+        if cls_name is None:
+            nbt_type = None
+        else:
+            assert isinstance(cls_name, str)
+            nbt_type = StrToNBTCls[cls_name]
+
+        return cls(
+            outer_name,
+            outer_type,
+            path,
+            key,
+            nbt_type,
+        )
+
+    def to_json(self) -> JSONDict:
+        options: JSONDict = {}
+        if self._outer_name:
+            options["outer_name"] = self._outer_name
+        if self._outer_type is not CompoundTag:
+            options["outer_type"] = NBTClsToStr[self._outer_type]
+        if self._path is not None:
+            options["path"] = [[key, NBTClsToStr[cls]] for key, cls in self._path]
+        if self._key is not None:
+            options["key"] = self._key
+        if self._tag_cls is not None:
+            options["type"] = NBTClsToStr[self._tag_cls]
+
+        return {"function": "carry_nbt", "options": options}
+
+    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
+        dst.cacheable = False
+
+        src_nbt = src.nbt
+        if src_nbt is None:
+            return
+
+        full_nbt_path = state.nbt_path
+        if full_nbt_path is None:
+            # This only works within walk_input_nbt
+            return
+
+        tag = follow_nbt_path(src_nbt, full_nbt_path)
+        if tag is None:
+            # Could not find the tag
+            return
+
+        nbt_path = full_nbt_path[2]
+        path = nbt_path[:-1] if self._path is None else self._path
+        src_key, src_cls = nbt_path[-1]
+        key = src_key if self._key is None else self._key
+        tag_cls = src_cls if self._tag_cls is None else self._tag_cls
+
+        if not isinstance(tag, tag_cls):
+            assert isinstance(tag, AbstractBaseNumericTag) and issubclass(
+                tag_cls, AbstractBaseNumericTag
+            )
+            tag = tag_cls(tag)
+        dst.nbt.append((self._outer_name, self._outer_type, path, key, tag))

amulet/game/translate/_functions/carry_properties.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Self, Any
+from collections.abc import Mapping, Iterable
+
+from amulet.block import PropertyValueType, Block
+
+from .abc import (
+    AbstractBaseTranslationFunction,
+    immutable_from_snbt,
+    Data,
+)
+from amulet.game.abc import JSONCompatible, JSONDict
+from ._frozen import FrozenMapping, OrderedFrozenSet
+from ._state import SrcData, StateData, DstData
+
+
+class CarryProperties(AbstractBaseTranslationFunction):
+    # Class variables
+    Name = "carry_properties"
+    _instances = {}
+
+    # Instance variables
+    _properties: FrozenMapping[str, OrderedFrozenSet[PropertyValueType]]
+
+    def __init__(self, properties: Mapping[str, Iterable[PropertyValueType]]) -> None:
+        super().__init__()
+        assert isinstance(properties, Mapping)
+        frozen_properties = {}
+        for key, val in properties.items():
+            frozen_val = OrderedFrozenSet(val)
+            if not (
+                isinstance(key, str)
+                and all(isinstance(v, PropertyValueType) for v in frozen_val)
+            ):
+                raise TypeError
+            frozen_properties[key] = frozen_val
+        self._properties = FrozenMapping[str, OrderedFrozenSet[PropertyValueType]](
+            frozen_properties
+        )
+
+    def __reduce__(self) -> Any:
+        return CarryProperties, (self._properties,)
+
+    def _data(self) -> Data:
+        return self._properties
+
+    @classmethod
+    def from_json(cls, data: JSONCompatible) -> Self:
+        assert isinstance(data, dict)
+        assert data.get("function") == "carry_properties"
+        options = data["options"]
+        assert isinstance(options, dict)
+        properties = {}
+        for property_name, snbt_list in options.items():
+            assert isinstance(property_name, str)
+            assert isinstance(snbt_list, list)
+            values = []
+            for snbt in snbt_list:
+                assert isinstance(snbt, str)
+                values.append(immutable_from_snbt(snbt))
+            properties[property_name] = values
+        return cls(properties)
+
+    def to_json(self) -> JSONDict:
+        return {
+            "function": "carry_properties",
+            "options": {
+                key: [v.to_snbt() for v in val] for key, val in self._properties.items()
+            },
+        }
+
+    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
+        block = src.block
+        assert isinstance(block, Block)
+        src_properties = block.properties
+        for key, options in self._properties.items():
+            val = src_properties.get(key)
+            if val is not None and val in options:
+                dst.properties[key] = val

amulet/game/translate/_functions/code.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from typing import Self, Any, TypeVar, Callable
+from collections.abc import Sequence
+
+from .abc import AbstractBaseTranslationFunction, Data
+from amulet.game.abc import JSONCompatible, JSONDict
+from ._state import SrcData, StateData, DstData
+
+from ._code_functions.banner_pattern import (
+    to_universal as banner_pattern_2u,
+    from_universal as banner_pattern_fu,
+)
+from ._code_functions.bedrock_chest_connection import (
+    bedrock_chest_connection_self,
+    bedrock_chest_connection_self_120,
+    bedrock_chest_connection_other_left,
+    bedrock_chest_connection_other_left_120,
+    bedrock_chest_connection_other_right,
+    bedrock_chest_connection_other_right_120,
+    from_universal as bedrock_chest_fu,
+)
+from ._code_functions.custom_name import (
+    bedrock_extended_to_universal as bedrock_custom_name_2u,
+    bedrock_extended_from_universal as bedrock_custom_name_fu,
+)
+from ._code_functions.bedrock_moving_block_pos import (
+    to_universal as bedrock_moving_block_pos_2u,
+    from_universal as bedrock_moving_block_pos_fu,
+)
+from ._code_functions.bedrock_sign import (
+    to_universal as bedrock_sign_2u,
+    from_universal as bedrock_sign_fu,
+    to_universal_120 as bedrock_sign_2u_120,
+    from_universal_120 as bedrock_sign_fu_120,
+)
+from ._code_functions.bedrock_skull_rotation import (
+    to_universal as bedrock_skull_rotation_2u,
+)
+
+
+T = TypeVar("T")
+
+
+def check_list(l: list[Any], t: type[T]) -> list[T]:
+    assert all(isinstance(el, t) for el in l)
+    return l
+
+
+FunctionLUT: dict[str, Callable[[SrcData, StateData, DstData], None]] = {
+    "banner_pattern_2u": banner_pattern_2u,
+    "banner_pattern_fu": banner_pattern_fu,
+    "bedrock_chest_connection_other_left": bedrock_chest_connection_other_left,
+    "bedrock_chest_connection_other_left_120": bedrock_chest_connection_other_left_120,
+    "bedrock_chest_connection_other_right": bedrock_chest_connection_other_right,
+    "bedrock_chest_connection_other_right_120": bedrock_chest_connection_other_right_120,
+    "bedrock_chest_connection_self": bedrock_chest_connection_self,
+    "bedrock_chest_connection_self_120": bedrock_chest_connection_self_120,
+    "bedrock_chest_fu": bedrock_chest_fu,
+    "bedrock_cmd_custom_name_2u": bedrock_custom_name_2u,
+    "bedrock_cmd_custom_name_fu": bedrock_custom_name_fu,
+    "bedrock_moving_block_pos_2u": bedrock_moving_block_pos_2u,
+    "bedrock_moving_block_pos_fu": bedrock_moving_block_pos_fu,
+    "bedrock_sign_2u": bedrock_sign_2u,
+    "bedrock_sign_2u_120": bedrock_sign_2u_120,
+    "bedrock_sign_fu": bedrock_sign_fu,
+    "bedrock_sign_fu_120": bedrock_sign_fu_120,
+    "bedrock_skull_rotation_2u": bedrock_skull_rotation_2u,
+}
+
+
+class Code(AbstractBaseTranslationFunction):
+    # Class variables
+    Name = "code"
+    _instances = {}
+
+    # Instance variables
+    _inputs: tuple[str, ...]
+    _outputs: tuple[str, ...]
+    _function_name: str
+
+    def __init__(
+        self,
+        inputs: Sequence[str],
+        outputs: Sequence[str],
+        function_name: str,
+    ) -> None:
+        super().__init__()
+        self._inputs = tuple(inputs)
+        assert all(
+            el
+            in {
+                "namespace",
+                "base_name",
+                "properties",
+                "nbt",
+                "location",
+            }
+            for el in self._inputs
+        )
+        self._outputs = tuple(outputs)
+        assert all(
+            el in {"output_name", "output_type", "new_properties", "new_nbt"}
+            for el in self._outputs
+        )
+        self._function_name = function_name
+
+    def __reduce__(self) -> Any:
+        return Code, (self._inputs, self._outputs, self._function_name)
+
+    def _data(self) -> Data:
+        return self._inputs, self._outputs, self._function_name
+
+    @classmethod
+    def from_json(cls, data: JSONCompatible) -> Self:
+        assert isinstance(data, dict)
+        assert data.get("function") == "code"
+        options = data["options"]
+        assert isinstance(options, dict)
+        raw_inputs = options["input"]
+        assert isinstance(raw_inputs, list)
+        inputs = check_list(raw_inputs, str)
+        raw_outputs = options["output"]
+        assert isinstance(raw_outputs, list)
+        outputs = check_list(raw_outputs, str)
+        function = options["function"]
+        assert isinstance(function, str)
+        assert function in FunctionLUT, function
+        return cls(inputs, outputs, function)
+
+    def to_json(self) -> JSONDict:
+        return {
+            "function": "code",
+            "options": {
+                "input": list(self._inputs),
+                "output": list(self._outputs),
+                "function": self._function_name,
+            },
+        }
+
+    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
+        dst.cacheable = False
+        FunctionLUT[self._function_name](src, state, dst)

amulet/game/translate/_functions/map_block_name.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Self, Any
+from collections.abc import Mapping
+
+from amulet.block import Block
+from .abc import (
+    AbstractBaseTranslationFunction,
+    translation_function_from_json,
+    Data,
+)
+from amulet.game.abc import JSONCompatible, JSONDict
+from ._frozen import FrozenMapping
+from ._state import SrcData, StateData, DstData
+
+
+class MapBlockName(AbstractBaseTranslationFunction):
+    # Class variables
+    Name = "map_block_name"
+    _instances = {}
+
+    # Instance variables
+    _blocks: FrozenMapping[tuple[str, str], AbstractBaseTranslationFunction]
+
+    def __init__(
+        self, blocks: Mapping[tuple[str, str], AbstractBaseTranslationFunction]
+    ) -> None:
+        super().__init__()
+        self._blocks = FrozenMapping[tuple[str, str], AbstractBaseTranslationFunction](
+            blocks
+        )
+
+    def __reduce__(self) -> Any:
+        return MapBlockName, (self._blocks,)
+
+    def _data(self) -> Data:
+        return self._blocks
+
+    @classmethod
+    def from_json(cls, data: JSONCompatible) -> Self:
+        assert isinstance(data, dict)
+        assert data.get("function") == "map_block_name"
+        blocks = {}
+        options = data["options"]
+        assert isinstance(options, dict)
+        for block_name, function in options.items():
+            assert isinstance(block_name, str)
+            namespace, base_name = block_name.split(":", 1)
+            blocks[(namespace, base_name)] = translation_function_from_json(function)
+        return cls(blocks)
+
+    def to_json(self) -> JSONDict:
+        return {
+            "function": "map_block_name",
+            "options": {
+                ":".join(block_name): func.to_json()
+                for block_name, func in self._blocks.items()
+            },
+        }
+
+    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
+        block = src.block
+        assert isinstance(block, Block)
+        func = self._blocks.get((block.namespace, block.base_name))
+        if func is not None:
+            func.run(src, state, dst)