amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp312-cp312-win_amd64.whl

amulet/game/translate/_functions/_typing.py

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

@@ -1,123 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Protocol, cast, Self, ClassVar, TypeVar
-from abc import 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 TranslationFunctionProtocol(Protocol):
-    _instances: ClassVar[dict[Self, Self]]
-
-
-T = TypeVar("T", bound=TranslationFunctionProtocol)
-
-
-class CacheMeta(ABCMeta):
-    """This modifies the construction of the instance to always return a cached instance, if one exists."""
-
-    def __call__(cls: type[T], *args: Any, **kwargs: Any) -> T:  # 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

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

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

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

@@ -1,66 +0,0 @@
-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)