amulet-core 2.0a5__cp312-cp312-macosx_10_13_universal2.whl

amulet/errors.py

@@ -0,0 +1,63 @@
+class DimensionDoesNotExist(Exception):
+    """An error thrown if trying to load data from a dimension that does not exist."""
+
+
+class ChunkLoadError(Exception):
+    """
+    An error thrown if a chunk failed to load for some reason.
+
+    This may be due to a corrupt chunk, an unsupported chunk format or just because the chunk does not exist to be loaded.
+
+    Catching this error will also catch :class:`ChunkDoesNotExist`
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkLoadError:
+    >>>     # will catch all chunks that have failed to load
+    >>>     # either because they do not exist or errored during loading.
+    """
+
+
+class ChunkDoesNotExist(ChunkLoadError):
+    """
+    An error thrown if a chunk does not exist and therefor cannot be loaded.
+
+    >>> try:
+    >>>     # get chunk
+    >>>     chunk = world.get_chunk(cx, cz, dimension)
+    >>> except ChunkDoesNotExist:
+    >>>     # will catch all chunks that do not exist
+    >>>     # will not catch corrupt chunks
+    >>> except ChunkLoadError:
+    >>>     # will only catch chunks that errored during loading
+    >>>     # chunks that do not exist were caught by the previous except section.
+    """
+
+
+class PlayerLoadError(Exception):
+    """
+    An error thrown if a player failed to load for some reason.
+    """
+
+
+class PlayerDoesNotExist(PlayerLoadError):
+    """
+    An error thrown if a player does not exist.
+    """
+
+
+class LevelReadError(Exception):
+    """
+    An error thrown when the raw level data cannot be read from.
+
+    This is usually because the data has been opened somewhere else.
+    """
+
+
+class LevelWriteError(Exception):
+    """
+    An error thrown when the raw level data cannot be written to.
+
+    This is usually because the data has been opened somewhere else.
+    """

amulet/game/__init__.py

@@ -0,0 +1,7 @@
+"""
+A module to store data about the game including state enumerations and translations between different game versions.
+"""
+
+from ._game import game_platforms, game_versions, get_game_version
+from .java import JavaGameVersion
+from .bedrock import BedrockGameVersion

amulet/game/_game.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import traceback
+from functools import cache
+from typing import overload, Literal, TYPE_CHECKING
+from collections.abc import Sequence
+from threading import RLock
+import pickle
+import os
+import glob
+import json
+import gzip
+
+from amulet.version import VersionNumber
+
+
+if TYPE_CHECKING:
+    from .abc import GameVersion
+    from ._universal import UniversalVersion
+    from .java import JavaGameVersion
+    from .bedrock import BedrockGameVersion
+
+
+_versions: dict[str, list[GameVersion]] | None = None
+_lock = RLock()
+
+
+def _compile_raw_versions() -> None:
+    global _versions
+    with _lock:
+        json_path = os.environ.get("AMULET_GAME_VERSION_JSON_PATH")
+        if json_path is None:
+            raise RuntimeError("Could not find game version data.")
+        from .java import JavaGameVersion
+        from .bedrock import BedrockGameVersion
+        from ._universal import UniversalVersion
+
+        _versions = {}
+        _versions.setdefault("universal", []).append(
+            UniversalVersion.from_json(os.path.join(json_path, "versions", "universal"))
+        )
+        for init_path in glob.glob(
+            os.path.join(glob.escape(json_path), "versions", "*", "__init__.json")
+        ):
+            version_path = os.path.dirname(init_path)
+
+            with open(os.path.join(version_path, "__init__.json")) as f:
+                init = json.load(f)
+
+            platform = init["platform"]
+            if platform == "bedrock":
+                _versions.setdefault("bedrock", []).append(
+                    BedrockGameVersion.from_json(version_path)
+                )
+            elif platform == "java":
+                _versions.setdefault("java", []).append(
+                    JavaGameVersion.from_json(version_path)
+                )
+            elif platform == "universal":
+                pass
+            else:
+                raise RuntimeError
+        with open(
+            os.path.join(os.path.dirname(__file__), "versions.pkl.gz"), "wb"
+        ) as pkl:
+            pkl.write(gzip.compress(pickle.dumps(_versions)))
+
+
+def _get_versions() -> dict[str, list[GameVersion]]:
+    global _versions
+    with _lock:
+        if _versions is None:
+            pkl_path = os.path.join(os.path.dirname(__file__), "versions.pkl.gz")
+            if os.path.isfile(pkl_path):
+                try:
+                    with open(pkl_path, "rb") as pkl:
+                        _versions = pickle.loads(gzip.decompress(pkl.read()))
+                except:
+                    traceback.print_exc()
+
+            if _versions is None:
+                _compile_raw_versions()
+
+    assert _versions is not None
+    return _versions
+
+
+def game_platforms() -> list[str]:
+    """
+    Get a list of all the platforms there are Version classes for.
+    These are currently 'java' and 'bedrock'
+    """
+    return list(_get_versions().keys())
+
+
+@overload
+def game_versions(platform: Literal["java"]) -> Sequence[JavaGameVersion]: ...
+
+
+@overload
+def game_versions(platform: Literal["bedrock"]) -> Sequence[BedrockGameVersion]: ...
+
+
+@overload
+def game_versions(platform: str) -> Sequence[GameVersion]: ...
+
+
+def game_versions(platform: str) -> Sequence[GameVersion]:
+    """
+    Get all known version classes for the platform.
+
+    :param platform: The platform name (use :attr:`platforms` to get the valid platforms)
+    :return: The version classes for the platform
+    :raises KeyError: If the platform is not present.
+    """
+    if platform not in _get_versions():
+        raise KeyError(f'The requested platform "{platform}" is not present')
+    return tuple(_get_versions()[platform])
+
+
+@overload
+def get_game_version(
+    platform: Literal["java"], version_number: VersionNumber
+) -> JavaGameVersion: ...
+
+
+@overload
+def get_game_version(
+    platform: Literal["bedrock"], version_number: VersionNumber
+) -> BedrockGameVersion: ...
+
+
+@overload
+def get_game_version(platform: str, version_number: VersionNumber) -> GameVersion: ...
+
+
+@cache  # type: ignore
+def get_game_version(platform: str, version_number: VersionNumber) -> GameVersion:
+    """
+    Get a Version class for the requested platform and version number
+
+    :param platform: The platform name (use ``TranslationManager.platforms`` to get the valid platforms)
+    :param version_number: The version number or DataVersion (use ``TranslationManager.version_numbers`` to get version numbers for a given platforms)
+    :return: The Version class for the given inputs.
+    :raises KeyError: If it does not exist.
+    """
+    if platform not in _get_versions():
+        raise KeyError(f'The requested platform "{platform}" is not present')
+    for version in _get_versions()[platform]:
+        if version.supports_version(platform, version_number):
+            return version
+    raise KeyError(f"Version {platform}, {version_number} is not supported")

amulet/game/_universal/__init__.py

@@ -0,0 +1 @@
+from ._version import UniversalVersion

amulet/game/_universal/_biome.py

@@ -0,0 +1,17 @@
+from amulet.biome import Biome
+from amulet.game.abc import BiomeData
+from amulet.version import VersionNumber
+
+
+class UniversalBiomeData(BiomeData):
+    def to_universal(self, biome: Biome) -> Biome:
+        if not self._game_version.supports_version(biome.platform, biome.version):
+            raise ValueError("The block is not compatible with this version")
+        return biome
+
+    def from_universal(
+        self, target_platform: str, target_version: VersionNumber, biome: Biome
+    ) -> Biome:
+        if not self._game_version.supports_version(biome.platform, biome.version):
+            raise ValueError("The block is not compatible with this version")
+        return biome

amulet/game/_universal/_block.py

@@ -0,0 +1,47 @@
+from typing import Callable
+
+from amulet.data_types import BlockCoordinates
+from amulet.block import Block
+from amulet.block_entity import BlockEntity
+from amulet.entity import Entity
+
+from amulet.game.abc import BlockData
+from amulet.version import VersionNumber
+
+
+class UniversalBlockData(BlockData):
+    def to_universal(
+        self,
+        block: Block,
+        block_entity: BlockEntity | None,
+        extra: (
+            tuple[
+                BlockCoordinates,
+                Callable[[BlockCoordinates], tuple[Block, BlockEntity | None]],
+            ]
+            | None
+        ),
+    ) -> tuple[Block, BlockEntity | None, bool]:
+        # Converting universal to universal so just return as is
+        if not self._game_version.supports_version(block.platform, block.version):
+            raise ValueError("The block is not compatible with this version")
+        return block, block_entity, False
+
+    def from_universal(
+        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] | tuple[Entity, None, bool]:
+        # Converting universal to universal so just return as is
+        if not self._game_version.supports_version(block.platform, block.version):
+            raise ValueError("The block is not compatible with this version")
+        return block, block_entity, False

amulet/game/_universal/_version.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from typing import Self
+import os
+import json
+
+from amulet.game.abc import GameVersion, load_json_block_spec, load_json_biome_data
+from amulet.version import VersionNumber
+
+from ._block import UniversalBlockData
+from ._biome import UniversalBiomeData
+
+
+class UniversalVersion(GameVersion):
+    _block: UniversalBlockData
+    _biome: UniversalBiomeData
+
+    @classmethod
+    def from_json(cls, version_path: str) -> Self:
+        with open(os.path.join(version_path, "__init__.json")) as f:
+            init = json.load(f)
+        assert init["platform"] == "universal"
+
+        block_format = init["block_format"]
+
+        self = cls()
+
+        # Load the block specification and translations
+        block_spec = load_json_block_spec(version_path, block_format)
+
+        self._block = UniversalBlockData(
+            self,
+            block_spec,
+        )
+
+        biomes, _, _ = load_json_biome_data(version_path)
+        biomes_namespace = dict[str, list[str]]()
+        for namespace, base_name in biomes:
+            biomes_namespace.setdefault(namespace, []).append(base_name)
+
+        self._biome = UniversalBiomeData(self, biomes_namespace)
+
+        return self
+
+    def __repr__(self) -> str:
+        return f"UniversalVersion()"
+
+    def supports_version(self, platform: str, version: VersionNumber) -> bool:
+        return platform == "universal"
+
+    @property
+    def platform(self) -> str:
+        return "universal"
+
+    @property
+    def min_version(self) -> VersionNumber:
+        return VersionNumber(1)
+
+    @property
+    def max_version(self) -> VersionNumber:
+        return VersionNumber(1)
+
+    @property
+    def block(self) -> UniversalBlockData:
+        return self._block
+
+    @property
+    def biome(self) -> UniversalBiomeData:
+        return self._biome

amulet/game/abc/__init__.py

@@ -0,0 +1,22 @@
+from .json_interface import JSONInterface, JSONCompatible, JSONDict, JSONList
+from .version import GameVersion
+from .block import (
+    BlockData,
+    DatabaseBlockData,
+    BlockDataNumericalComponent,
+    BlockTranslationError,
+)
+from .biome import (
+    BiomeData,
+    DatabaseBiomeData,
+    BiomeDataNumericalComponent,
+    BiomeTranslationError,
+    load_json_biome_data,
+)
+from ._block_specification import (
+    BlockSpec,
+    NBTSpec,
+    PropertySpec,
+    PropertyValueSpec,
+    load_json_block_spec,
+)

amulet/game/abc/_block_specification.py

@@ -0,0 +1,150 @@
+from typing import Self
+from types import MappingProxyType
+from collections.abc import Mapping, Iterator, Hashable
+from dataclasses import dataclass, field
+import os
+import json
+import glob
+from concurrent.futures import ThreadPoolExecutor
+
+from amulet_nbt import read_snbt
+from amulet.block import PropertyValueType
+
+from .json_interface import JSONInterface, JSONDict, JSONCompatible
+
+
+def immutable_from_snbt(snbt: str) -> PropertyValueType:
+    val = read_snbt(snbt)
+    assert isinstance(val, PropertyValueType)
+    return val
+
+
+@dataclass(frozen=True)
+class PropertyValueSpec:
+    default: PropertyValueType
+    states: tuple[PropertyValueType, ...]
+
+
+class PropertySpec(Mapping[str, PropertyValueSpec], Hashable):
+    _properties: Mapping[str, PropertyValueSpec]
+    _hash: int | None
+
+    def __init__(
+        self, properties: Mapping[str, PropertyValueSpec] = MappingProxyType({})
+    ):
+        self._properties = dict(properties)
+        self._hash = None
+
+    def __getitem__(self, name: str) -> PropertyValueSpec:
+        return self._properties[name]
+
+    def __len__(self) -> int:
+        return len(self._properties)
+
+    def __iter__(self) -> Iterator[str]:
+        yield from self._properties
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(frozenset(self._properties.items()))
+        return self._hash
+
+
+@dataclass(frozen=True)
+class NBTSpec:
+    namespace: str
+    base_name: str
+    snbt: str
+
+
+@dataclass(frozen=True)
+class BlockSpec(JSONInterface):
+    properties: PropertySpec = field(default_factory=PropertySpec)
+    nbt: NBTSpec | None = None
+
+    @classmethod
+    def from_json(cls, obj: JSONCompatible) -> Self:
+        assert isinstance(obj, dict)
+        properties = obj.get("properties", {})
+        default_properties = obj.get("defaults", {})
+        assert isinstance(properties, dict) and isinstance(default_properties, dict)
+        assert properties.keys() == default_properties.keys()
+
+        properties_data = {}
+        for name, values in properties.items():
+            assert isinstance(values, list)
+            default_str = default_properties[name]
+            assert isinstance(default_str, str)
+            default_nbt = immutable_from_snbt(default_str)
+
+            states: list[PropertyValueType] = []
+            for val_str in values:
+                assert isinstance(val_str, str)
+                val_nbt = immutable_from_snbt(val_str)
+                states.append(val_nbt)
+
+            properties_data[name] = PropertyValueSpec(default_nbt, tuple(states))
+
+        if "nbt_identifier" in obj:
+            nbt_id_raw = obj["nbt_identifier"]
+            assert isinstance(nbt_id_raw, list)
+            namespace, base_name = nbt_id_raw
+            assert isinstance(namespace, str) and isinstance(base_name, str)
+
+            snbt = obj["snbt"]
+            assert isinstance(snbt, str)
+            nbt = NBTSpec(namespace, base_name, snbt)
+        else:
+            nbt = None
+            assert "snbt" not in obj
+
+        assert not set(obj.keys()).difference(
+            ("properties", "defaults", "nbt_identifier", "snbt")
+        ), obj.keys()
+
+        return cls(PropertySpec(properties_data), nbt)
+
+    def to_json(self) -> JSONDict:
+        spec: JSONDict = {}
+        if self.properties:
+            spec["properties"] = properties = {}
+            spec["defaults"] = defaults = {}
+            for name, state in self.properties.items():
+                properties[name] = [val.to_snbt() for val in state.states]
+                defaults[name] = state.default.to_snbt()
+        if self.nbt is not None:
+            spec["nbt_identifier"] = [self.nbt.namespace, self.nbt.base_name]
+            spec["snbt"] = self.nbt.snbt
+        return spec
+
+
+def _read_glob(path: str) -> str:
+    with open(path) as f:
+        return f.read()
+
+
+def load_json_block_spec(
+    version_path: str, block_format: str
+) -> dict[str, dict[str, BlockSpec]]:
+    """Load all block specification files for the given version."""
+    block_spec = dict[str, dict[str, BlockSpec]]()
+    paths = glob.glob(
+        os.path.join(
+            glob.escape(version_path),
+            "block",
+            block_format,
+            "specification",
+            "*",
+            "*",
+            "*.json",
+        )
+    )
+    with ThreadPoolExecutor() as e:
+        for file_path, data in zip(paths, e.map(_read_glob, paths)):
+            *_, namespace, _, base_name = os.path.splitext(os.path.normpath(file_path))[
+                0
+            ].split(os.sep)
+            block_spec.setdefault(namespace, {})[base_name] = BlockSpec.from_json(
+                json.loads(data)
+            )
+    return block_spec