amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp311-cp311-win_amd64.whl

amulet/game/_game.py

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

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

amulet/game/_universal/_biome.py

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

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

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

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

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

amulet/game/abc/biome.py

@@ -1,213 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from abc import ABC, abstractmethod
-from collections.abc import Mapping, Collection
-import os
-import json
-
-from amulet.biome import Biome
-from amulet.version import VersionNumber
-from amulet.game import get_game_version
-
-from .game_version_container import GameVersionContainer
-
-
-if TYPE_CHECKING:
-    from .version import GameVersion
-
-
-class BiomeTranslationError(Exception):
-    """An exception raised if the biome could not be translated."""
-
-
-class BiomeData(GameVersionContainer, ABC):
-    _biomes: Mapping[str, Collection[str]]
-
-    def __init__(
-        self, game_version: GameVersion, biomes: Mapping[str, Collection[str]]
-    ):
-        super().__init__(game_version)
-        self._biomes = {
-            namespace: tuple(base_names) for namespace, base_names in biomes.items()
-        }
-
-    def __getstate__(self) -> dict:
-        state = super().__getstate__()
-        state["_biomes"] = self._biomes
-        return state
-
-    def __setstate__(self, state: dict) -> None:
-        super().__setstate__(state)
-        self._biomes = state["_biomes"]
-
-    def namespaces(self) -> Collection[str]:
-        """An iterable of all the valid biome namespaces."""
-        return self._biomes.keys()
-
-    def base_names(self, namespace: str) -> Collection[str]:
-        """An iterable of all valid base names for the given namespace."""
-        return self._biomes[namespace]
-
-    def translate(
-        self, target_platform: str, target_version: VersionNumber, biome: Biome
-    ) -> Biome:
-        """Translate a biome from this version to the target version specified.
-
-        :param target_platform: The game platform to convert to.
-        :param target_version: The game version number to convert to.
-        :param biome: The biome to translate.
-        :return: The biome converted to the output version.
-        :raises:
-            ValueError: The arguments are incorrect. You did something wrong.
-            BlockTranslationError: The translator is not aware of the biome. You should handle a sensible default.
-        """
-        target_game_version = get_game_version(target_platform, target_version)
-        universal_biome = self.to_universal(biome)
-        return target_game_version.biome.from_universal(
-            target_platform, target_version, universal_biome
-        )
-
-    @abstractmethod
-    def to_universal(self, biome: Biome) -> Biome:
-        """Convert a biome to the universal format.
-
-        This method should be considered private.
-
-        :meta private:
-        :param biome: The biome to translate.
-        :return: The biome converted to the universal version.
-        :raises:
-            ValueError: The arguments are incorrect. You did something wrong.
-            BlockTranslationError: The translator is not aware of the biome. You should handle a sensible default.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def from_universal(
-        self, target_platform: str, target_version: VersionNumber, biome: Biome
-    ) -> Biome:
-        """Convert a biome from the universal format.
-
-        This method should be considered private.
-
-        :meta private:
-        :param target_platform: The game platform to convert to.
-        :param target_version: The game version number to convert to.
-        :param biome: The biome to translate.
-        :return: The biome converted to this version.
-        :raises:
-            ValueError: The arguments are incorrect. You did something wrong.
-            BlockTranslationError: The translator is not aware of the biome. You should handle a sensible default.
-        """
-        raise NotImplementedError
-
-
-class DatabaseBiomeData(BiomeData):
-    _to_universal: Mapping[tuple[str, str], Biome]
-    _from_universal: Mapping[Biome, tuple[str, str]]
-
-    def __init__(
-        self,
-        game_version: GameVersion,
-        biomes: Mapping[str, Collection[str]],
-        to_universal: Mapping[tuple[str, str], Biome],
-        from_universal: Mapping[Biome, tuple[str, str]],
-    ):
-        super().__init__(game_version, biomes)
-        self._to_universal = to_universal
-        self._from_universal = from_universal
-
-    def __getstate__(self) -> dict:
-        state = super().__getstate__()
-        state["_to_universal"] = self._to_universal
-        state["_from_universal"] = self._from_universal
-        return state
-
-    def __setstate__(self, state: dict) -> None:
-        super().__setstate__(state)
-        self._to_universal = state["_to_universal"]
-        self._from_universal = state["_from_universal"]
-
-    def to_universal(self, biome: Biome) -> Biome:
-        if not self._game_version.supports_version(biome.platform, biome.version):
-            raise ValueError("The biome is not compatible with this version")
-
-        try:
-            return self._to_universal[(biome.namespace, biome.base_name)]
-        except KeyError:
-            raise BiomeTranslationError(
-                f"Biome {biome} does not exist in version {self._game_version.platform} {self._game_version.min_version}"
-            )
-
-    def from_universal(
-        self, target_platform: str, target_version: VersionNumber, biome: Biome
-    ) -> Biome:
-        if not self._game_version.supports_version(target_platform, target_version):
-            raise ValueError("The target version is not compatible with this version")
-
-        if biome.platform != "universal":
-            raise ValueError("The source biome is not in the universal format")
-
-        try:
-            namespace, base_name = self._from_universal[biome]
-        except KeyError:
-            raise BiomeTranslationError(
-                f"Biome {biome} does not exist in version {self._game_version.platform} {self._game_version.min_version}"
-            )
-        else:
-            return Biome(target_platform, target_version, namespace, base_name)
-
-
-class BiomeDataNumericalComponent(ABC):
-    @abstractmethod
-    def numerical_id_to_namespace_id(self, numerical_id: int) -> tuple[str, str]:
-        """Convert the numerical id to its namespace id"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def namespace_id_to_numerical_id(self, namespace: str, base_name: str) -> int:
-        raise NotImplementedError
-
-
-def load_json_biome_data(
-    version_path: str,
-) -> tuple[
-    dict[tuple[str, str], int | None],
-    dict[tuple[str, str], tuple[str, str]],
-    dict[tuple[str, str], tuple[str, str]],
-]:
-    with open(os.path.join(version_path, "__biome_data__.json")) as f:
-        data = json.load(f)
-
-    biomes = dict[tuple[str, str], int | None]()
-    to_universal = dict[tuple[str, str], tuple[str, str]]()
-    from_universal = dict[tuple[str, str], tuple[str, str]]()
-
-    for biome_str, biome_int in data["int_map"].items():
-        assert isinstance(biome_str, str)
-        assert isinstance(biome_int, int) or biome_int is None
-        namespace, base_name = biome_str.split(":", 1)
-        biomes[(namespace, base_name)] = biome_int
-
-    for biome_str, universal_biome_str in data["version2universal"].items():
-        assert isinstance(biome_str, str)
-        assert isinstance(universal_biome_str, str)
-        namespace, base_name = biome_str.split(":", 1)
-        universal_namespace, universal_base_name = biome_str.split(":", 1)
-        to_universal[(namespace, base_name)] = (
-            universal_namespace,
-            universal_base_name,
-        )
-
-    for universal_biome_str, biome_str in data["universal2version"].items():
-        assert isinstance(biome_str, str)
-        assert isinstance(universal_biome_str, str)
-        namespace, base_name = biome_str.split(":", 1)
-        universal_namespace, universal_base_name = biome_str.split(":", 1)
-        from_universal[(universal_namespace, universal_base_name)] = (
-            namespace,
-            base_name,
-        )
-
-    return biomes, to_universal, from_universal