amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1a2.post250529084738__cp311-cp311-win_amd64.whl

amulet/game/translate/_functions/map_nbt.py

@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-from typing import Self, Any
-from collections.abc import Mapping
-
-from .abc import (
-    AbstractBaseTranslationFunction,
-    translation_function_from_json,
-    Data,
-    follow_nbt_path,
-)
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._frozen import FrozenMapping
-from ._state import SrcData, StateData, DstData
-
-
-class MapNBT(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "map_nbt"
-    _instances = {}
-
-    # Instance variables
-    _cases: FrozenMapping[
-        str,
-        AbstractBaseTranslationFunction,
-    ]
-    _default: AbstractBaseTranslationFunction | None
-
-    def __init__(
-        self,
-        cases: Mapping[
-            str,
-            AbstractBaseTranslationFunction,
-        ],
-        default: AbstractBaseTranslationFunction | None,
-    ) -> None:
-        super().__init__()
-        self._cases = FrozenMapping[
-            str,
-            AbstractBaseTranslationFunction,
-        ](cases)
-        assert all(
-            isinstance(
-                key,
-                str,
-            )
-            and isinstance(value, AbstractBaseTranslationFunction)
-            for key, value in self._cases.items()
-        )
-        assert default is None or isinstance(default, AbstractBaseTranslationFunction)
-        self._default = default
-
-    def __reduce__(self) -> Any:
-        return MapNBT, (self._cases, self._default)
-
-    def _data(self) -> Data:
-        return self._cases, self._default
-
-    @classmethod
-    def from_json(cls, data: JSONCompatible) -> Self:
-        assert isinstance(data, dict)
-        assert data.get("function") == "map_nbt"
-        options = data["options"]
-        assert isinstance(options, dict)
-        cases = options.get("cases", {})
-        assert isinstance(cases, dict)
-        raw_default = options.get("default", None)
-        if raw_default is None:
-            default = None
-        else:
-            assert isinstance(raw_default, list)
-            default = translation_function_from_json(raw_default)
-        return cls(
-            {
-                key: translation_function_from_json(value)
-                for key, value in cases.items()
-            },
-            default,
-        )
-
-    def to_json(self) -> JSONDict:
-        options: JSONDict = {}
-        if self._cases:
-            options["cases"] = {
-                key: value.to_json() for key, value in self._cases.items()
-            }
-        if self._default:
-            options["default"] = self._default.to_json()
-        return {"function": "map_nbt", "options": options}
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        dst.cacheable = False
-        if src.nbt is None:
-            dst.extra_needed = True
-            return
-
-        if state.nbt_path is None:
-            return
-
-        run_default = True
-
-        if self._cases:
-            nbt = follow_nbt_path(src.nbt, state.nbt_path)
-            if nbt is not None:
-                nbt_hash = nbt.to_snbt()
-                if nbt_hash in self._cases:
-                    self._cases[nbt_hash].run(src, state, dst)
-                    run_default = False
-
-        if run_default and self._default is not None:
-            self._default.run(src, state, dst)

amulet/game/translate/_functions/map_properties.py

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-from typing import Self, Any
-from collections.abc import Mapping
-
-from amulet.block import PropertyValueType, Block
-from .abc import (
-    AbstractBaseTranslationFunction,
-    immutable_from_snbt,
-    translation_function_from_json,
-    Data,
-)
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._frozen import FrozenMapping
-from ._state import SrcData, StateData, DstData
-
-
-class MapProperties(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "map_properties"
-    _instances = {}
-
-    # Instance variables
-    _properties: FrozenMapping[
-        str, FrozenMapping[PropertyValueType, AbstractBaseTranslationFunction]
-    ]
-
-    def __init__(
-        self,
-        properties: Mapping[
-            str, Mapping[PropertyValueType, AbstractBaseTranslationFunction]
-        ],
-    ) -> None:
-        super().__init__()
-        hashable_properties = {}
-
-        for prop, data in properties.items():
-            assert isinstance(prop, str)
-            hashable_data = FrozenMapping[
-                PropertyValueType, AbstractBaseTranslationFunction
-            ](data)
-            for val, func in hashable_data.items():
-                assert isinstance(val, PropertyValueType)
-                assert isinstance(func, AbstractBaseTranslationFunction)
-            hashable_properties[prop] = hashable_data
-
-        self._properties = FrozenMapping[
-            str, FrozenMapping[PropertyValueType, AbstractBaseTranslationFunction]
-        ](hashable_properties)
-
-    def __reduce__(self) -> Any:
-        return MapProperties, (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") == "map_properties"
-        options = data["options"]
-        assert isinstance(options, dict)
-        properties = {}
-        for property_name, mapping in options.items():
-            assert isinstance(property_name, str)
-            assert isinstance(mapping, dict)
-            values = {}
-            for snbt, func in mapping.items():
-                assert isinstance(snbt, str)
-                assert isinstance(func, dict | list)
-                values[immutable_from_snbt(snbt)] = translation_function_from_json(func)
-            properties[property_name] = values
-        return cls(properties)
-
-    def to_json(self) -> JSONDict:
-        return {
-            "function": "map_properties",
-            "options": {
-                property_name: {
-                    nbt.to_snbt(): func.to_json() for nbt, func in mapping.items()
-                }
-                for property_name, mapping 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:
-                options[val].run(src, state, dst)

amulet/game/translate/_functions/multiblock.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-from typing import Sequence, Self, Any
-
-from amulet.data_types import BlockCoordinates
-from amulet.errors import ChunkLoadError
-from .abc import (
-    AbstractBaseTranslationFunction,
-    Data,
-    translation_function_from_json,
-)
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._state import SrcData, SrcDataExtra, StateData, DstData
-
-
-class MultiBlock(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "multiblock"
-    _instances = {}
-
-    _blocks: tuple[tuple[BlockCoordinates, AbstractBaseTranslationFunction], ...]
-
-    def __init__(
-        self, blocks: Sequence[tuple[BlockCoordinates, AbstractBaseTranslationFunction]]
-    ) -> None:
-        super().__init__()
-        self._blocks = tuple[
-            tuple[BlockCoordinates, AbstractBaseTranslationFunction], ...
-        ](blocks)
-        for coords, func in self._blocks:
-            if (
-                not isinstance(coords, tuple)
-                and len(coords) == 3
-                and all(isinstance(v, int) for v in coords)
-            ):
-                raise TypeError
-            assert isinstance(func, AbstractBaseTranslationFunction)
-
-    def __reduce__(self) -> Any:
-        return MultiBlock, (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") == "multiblock"
-        options = data["options"]
-        assert isinstance(options, list)
-        blocks: list[tuple[BlockCoordinates, AbstractBaseTranslationFunction]] = []
-        for block in options:
-            assert isinstance(block, dict)
-            raw_coords = block["coords"]
-            assert isinstance(raw_coords, list)
-            x = raw_coords[0]
-            y = raw_coords[1]
-            z = raw_coords[2]
-            assert isinstance(x, int)
-            assert isinstance(y, int)
-            assert isinstance(z, int)
-            coords = (x, y, z)
-            function = translation_function_from_json(block["functions"])
-            blocks.append((coords, function))
-        return cls(blocks)
-
-    def to_json(self) -> JSONDict:
-        return {
-            "function": "multiblock",
-            "options": [
-                {"coords": list(coords), "functions": func.to_json()}
-                for coords, func in self._blocks
-            ],
-        }
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        dst.cacheable = False
-        if src.extra is None:
-            dst.extra_needed = True
-            return
-
-        for (dx, dy, dz), func in self._blocks:
-            rx, ry, rz = state.relative_location
-            new_relative_location = (
-                rx + dx,
-                ry + dy,
-                rz + dz,
-            )
-            try:
-                new_block, new_block_entity = src.extra.get_block_callback(
-                    new_relative_location
-                )
-            except ChunkLoadError:
-                continue
-            else:
-                ax, ay, az = src.extra.absolute_coordinates
-                new_absolute_location = (
-                    ax + dx,
-                    ay + dy,
-                    az + dz,
-                )
-                # src is now the block at the new location
-                new_src = SrcData(
-                    new_block,
-                    None if new_block_entity is None else new_block_entity.nbt,
-                    SrcDataExtra(
-                        new_absolute_location,
-                        src.extra.get_block_callback,
-                    ),
-                )
-                new_state = StateData(new_relative_location)
-                func.run(new_src, new_state, dst)

amulet/game/translate/_functions/new_block.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from typing import Self, Any
-from amulet.block import Block
-from .abc import AbstractBaseTranslationFunction, Data
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._state import SrcData, StateData, DstData
-
-
-class NewBlock(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "new_block"
-    _instances = {}
-
-    # Instance variables
-    _block: tuple[str, str]
-
-    def __init__(self, namespace: str, base_name: str) -> None:
-        super().__init__()
-        self._block = (namespace, base_name)
-
-    def __reduce__(self) -> Any:
-        return NewBlock, (self._block[0], self._block[1])
-
-    def _data(self) -> Data:
-        return self._block
-
-    @classmethod
-    def from_json(cls, data: JSONCompatible) -> Self:
-        assert isinstance(data, dict)
-        assert data.get("function") == "new_block"
-        block = data["options"]
-        assert isinstance(block, str)
-        namespace, base_name = block.split(":", 1)
-        return cls(namespace, base_name)
-
-    def to_json(self) -> JSONDict:
-        return {"function": "new_block", "options": ":".join(self._block)}
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        dst.cls = Block
-        dst.resource_id = self._block

amulet/game/translate/_functions/new_entity.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from typing import Self, Any
-
-from amulet.entity import Entity
-from .abc import AbstractBaseTranslationFunction, Data
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._state import SrcData, StateData, DstData
-
-
-class NewEntity(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "new_entity"
-    _instances = {}
-
-    # Instance variables
-    _entity: tuple[str, str]
-
-    def __init__(self, namespace: str, base_name: str) -> None:
-        super().__init__()
-        self._entity = (namespace, base_name)
-
-    def __reduce__(self) -> Any:
-        return NewEntity, (self._entity,)
-
-    def _data(self) -> Data:
-        return self._entity
-
-    @classmethod
-    def from_json(cls, data: JSONCompatible) -> Self:
-        assert isinstance(data, dict)
-        assert data.get("function") == "new_entity"
-        entity = data["options"]
-        assert isinstance(entity, str)
-        namespace, base_name = entity.split(":", 1)
-        return cls(namespace, base_name)
-
-    def to_json(self) -> JSONDict:
-        return {"function": "new_entity", "options": ":".join(self._entity)}
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        dst.cls = Entity
-        dst.resource_id = self._entity

amulet/game/translate/_functions/new_nbt.py

@@ -1,206 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    Sequence,
-    Self,
-    Any,
-)
-
-from amulet_nbt import (
-    ListTag,
-    CompoundTag,
-    read_snbt,
-)
-
-from .abc import (
-    AbstractBaseTranslationFunction,
-    Data,
-)
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._typing import (
-    NBTTagT,
-    NBTTagClasses,
-    NBTClsToStr,
-    StrToNBTCls,
-    NBTPath,
-    NBTPathElement,
-)
-from ._state import SrcData, StateData, DstData
-
-
-class NewNBTItem(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "_new_nbt"
-    _instances = {}
-
-    # Instance variables
-    _key: str | int
-    _value: NBTTagT
-    _snbt: str
-    _outer_name: str
-    _outer_type: type[CompoundTag] | type[ListTag]
-    _path: NBTPath | None
-
-    def __init__(
-        self,
-        key: str | int,
-        value: NBTTagT,
-        outer_name: str = "",
-        outer_type: type[CompoundTag] | type[ListTag] = CompoundTag,
-        path: (
-            Sequence[tuple[str | int, type[CompoundTag] | type[ListTag]]] | None
-        ) = None,
-    ) -> None:
-        super().__init__()
-        assert isinstance(outer_name, str)
-        self._outer_name = outer_name
-
-        assert outer_type in NBTClsToStr
-        self._outer_type = outer_type
-        last_cls = outer_type
-
-        if path is None:
-            self._path = None
-        else:
-            path_l = list(path)
-            for i, (path_key, nbt_cls) in enumerate(path_l):
-                assert nbt_cls is CompoundTag or nbt_cls is ListTag
-                assert (last_cls is CompoundTag and isinstance(path_key, str)) or (
-                    last_cls is ListTag and isinstance(path_key, int)
-                )
-
-                path_l[i] = (path_key, nbt_cls)
-                last_cls = nbt_cls
-            self._path = tuple[NBTPathElement, ...](path_l)
-
-        assert isinstance(key, (str, int))
-        if self._path is not None:
-            if last_cls is CompoundTag:
-                assert isinstance(key, str)
-            elif last_cls is ListTag:
-                assert isinstance(key, int)
-        self._key = key
-
-        assert isinstance(value, NBTTagClasses)
-        self._snbt = value.to_snbt()
-        self._value = value
-
-    def __reduce__(self) -> Any:
-        return NewNBTItem, (
-            self._key,
-            self._value,
-            self._outer_name,
-            self._outer_type,
-            self._path,
-        )
-
-    def _data(self) -> Data:
-        return (
-            self._outer_name,
-            self._outer_type,
-            self._path,
-            self._key,
-            self._snbt,
-        )
-
-    @classmethod
-    def from_json(cls, data: JSONCompatible) -> Self:
-        assert isinstance(data, dict)
-
-        key = data["key"]
-        assert isinstance(key, str | int)
-        raw_value = data["value"]
-        assert isinstance(raw_value, str)
-        outer_name = data.get("outer_name", "")
-        assert isinstance(outer_name, str)
-        outer_type = data.get("outer_type", "compound")
-        assert isinstance(outer_type, str)
-        raw_path = data.get("path", None)
-        if raw_path is None:
-            path = None
-        else:
-            assert isinstance(raw_path, list)
-            path = []
-            for item in raw_path:
-                assert isinstance(item, list) and len(item) == 2
-                cls_key, cls_name = item
-                assert isinstance(cls_key, str | int)
-                assert isinstance(cls_name, str)
-                path.append((cls_key, StrToNBTCls[cls_name]))
-
-        return cls(
-            key,
-            read_snbt(raw_value),
-            outer_name,
-            StrToNBTCls[outer_type],
-            path,
-        )
-
-    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[value]] for key, value in self._path]
-        options["key"] = self._key
-        options["value"] = self._value.to_snbt()
-        return options
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        path: NBTPath
-        if self._path is None:
-            walked_path = state.nbt_path
-            if walked_path is None:
-                # If not used within walk_input_nbt then default to the root
-                path = ()
-            else:
-                # If used within walk_input_nbt default to
-                path = walked_path[2]
-        else:
-            # If path is defined then use that
-            path = self._path
-
-        dst.nbt.append(
-            (self._outer_name, self._outer_type, path, self._key, self._value)
-        )
-
-
-class NewNBT(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "new_nbt"
-    _instances = {}
-
-    # Instance variables
-    _new_nbt: tuple[NewNBTItem, ...]
-
-    def __init__(self, *new_nbt: NewNBTItem) -> None:
-        super().__init__()
-        self._new_nbt = tuple(new_nbt)
-        if not all(isinstance(nbt, NewNBTItem) for nbt in self._new_nbt):
-            raise TypeError
-
-    def __reduce__(self) -> Any:
-        return NewNBT, (*self._new_nbt,)
-
-    def _data(self) -> Data:
-        return self._new_nbt
-
-    @classmethod
-    def from_json(cls, data: JSONCompatible) -> Self:
-        assert isinstance(data, dict)
-        assert data.get("function") == "new_nbt"
-        options = data["options"]
-        assert isinstance(options, list)
-        return cls(*(NewNBTItem.from_json(opt) for opt in options))
-
-    def to_json(self) -> JSONDict:
-        return {
-            "function": "new_nbt",
-            "options": [opt.to_json() for opt in self._new_nbt],
-        }
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        for item in self._new_nbt:
-            item.run(src, state, dst)

amulet/game/translate/_functions/new_properties.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from typing import Self, Any
-from collections.abc import Mapping
-
-from amulet.block import PropertyValueType
-from .abc import (
-    AbstractBaseTranslationFunction,
-    immutable_from_snbt,
-    Data,
-)
-from amulet.game.abc import JSONCompatible, JSONDict
-from ._frozen import FrozenMapping
-from ._state import SrcData, StateData, DstData
-
-
-class NewProperties(AbstractBaseTranslationFunction):
-    # Class variables
-    Name = "new_properties"
-    _instances = {}
-
-    # Instance variables
-    _properties: FrozenMapping[str, PropertyValueType]
-
-    def __init__(self, properties: Mapping[str, PropertyValueType]) -> None:
-        super().__init__()
-        self._properties = FrozenMapping[str, PropertyValueType](properties)
-        if not all(isinstance(key, str) for key in self._properties.keys()):
-            raise TypeError
-        if not all(
-            isinstance(value, PropertyValueType) for value in self._properties.values()
-        ):
-            raise TypeError
-
-    def __reduce__(self) -> Any:
-        return NewProperties, (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") == "new_properties"
-        options = data["options"]
-        assert isinstance(options, dict)
-        properties = {}
-        for property_name, snbt in options.items():
-            assert isinstance(property_name, str)
-            assert isinstance(snbt, str)
-            properties[property_name] = immutable_from_snbt(snbt)
-        return cls(properties)
-
-    def to_json(self) -> JSONDict:
-        return {
-            "function": "new_properties",
-            "options": {
-                property_name: tag.to_snbt()
-                for property_name, tag in self._properties.items()
-            },
-        }
-
-    def run(self, src: SrcData, state: StateData, dst: DstData) -> None:
-        dst.properties.update(self._properties)