amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1a2.post250529084747__cp312-cp312-win_amd64.whl

amulet/core/__init__.py

@@ -0,0 +1,36 @@
+import logging
+
+from . import _version
+
+__version__ = _version.get_versions()["version"]
+
+# init a default logger
+logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")
+
+
+def _init() -> None:
+    import os
+    import sys
+    import ctypes
+
+    if sys.platform == "win32":
+        lib_path = os.path.join(os.path.dirname(__file__), "amulet_core.dll")
+    elif sys.platform == "darwin":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_core.dylib")
+    elif sys.platform == "linux":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_core.so")
+    else:
+        raise RuntimeError(f"Unsupported platform {sys.platform}")
+
+    # Import dependencies
+    import amulet.nbt
+
+    # Load the shared library
+    ctypes.cdll.LoadLibrary(lib_path)
+
+    from ._amulet_core import init
+
+    init(sys.modules[__name__])
+
+
+_init()

amulet/core/__pyinstaller/hook-amulet.core.py

@@ -0,0 +1,4 @@
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+hiddenimports = collect_submodules("amulet.core")
+datas = collect_data_files("amulet.core")

amulet/core/_amulet_core.pyi

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import types
+
+__all__ = ["init"]
+
+def init(arg0: types.ModuleType) -> None: ...

amulet/{_version.py → core/_version.py}

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-27T10:30:17+0000",
+ "date": "2025-05-29T09:42:08+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "7844bec50b93c8711ae703840b1a0e43b8283df6",
- "version": "2.0a8"
+ "full-revisionid": "5a4364bf92e8e1d1a3ccb77de14d813c5bb40acc",
+ "version": "2.0.1a2"
 }
 '''  # END VERSION_JSON
 

amulet/core/amulet_coreConfig.cmake

@@ -0,0 +1,18 @@
+if (NOT TARGET amulet_core)
+    message(STATUS "Finding amulet_core")
+
+    find_package(amulet_io CONFIG REQUIRED)
+    find_package(amulet_nbt CONFIG REQUIRED)
+
+    set(amulet_core_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
+    find_library(amulet_core_LIBRARY NAMES amulet_core PATHS "${CMAKE_CURRENT_LIST_DIR}")
+    message(STATUS "amulet_core_LIBRARY: ${amulet_core_LIBRARY}")
+
+    add_library(amulet_core SHARED IMPORTED)
+    set_target_properties(amulet_core PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${amulet_core_INCLUDE_DIR}"
+        INTERFACE_LINK_LIBRARIES amulet_io
+        INTERFACE_LINK_LIBRARIES amulet_nbt
+        IMPORTED_IMPLIB "${amulet_core_LIBRARY}"
+    )
+endif()

amulet/{biome.pyi → core/biome/__init__.pyi}

@@ -3,11 +3,11 @@ from __future__ import annotations
 import types
 import typing
 
-import amulet.version
+import amulet.core.version
 
 __all__ = ["Biome"]
 
-class Biome(amulet.version.PlatformVersionContainer):
+class Biome(amulet.core.version.PlatformVersionContainer):
     """
     A class to manage the state of a biome.
 
@@ -34,7 +34,7 @@ class Biome(amulet.version.PlatformVersionContainer):
     def __init__(
         self,
         platform: str,
-        version: amulet.version.VersionNumber,
+        version: amulet.core.version.VersionNumber,
         namespace: str,
         base_name: str,
     ) -> None: ...

amulet/core/biome/biome.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+class Biome : public PlatformVersionContainer {
+private:
+    std::string _namespace;
+    std::string _base_name;
+
+public:
+    const std::string& get_namespace() const { return _namespace; }
+    const std::string& get_base_name() const { return _base_name; }
+
+    template <typename PlatformT, typename VersionT, typename NamespaceT, typename BaseNameT>
+    Biome(
+        PlatformT&& platform,
+        VersionT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static Biome deserialise(BinaryReader&);
+
+    auto operator<=>(const Biome& other) const
+    {
+        auto cmp = PlatformVersionContainer::operator<=>(other);
+        if (cmp != 0) {
+            return cmp;
+        }
+        cmp = _namespace <=> other._namespace;
+        if (cmp != 0) {
+            return cmp;
+        }
+        return _base_name <=> other._base_name;
+    }
+    bool operator==(const Biome& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+};
+}

amulet/{block.pyi → core/block/__init__.pyi}

@@ -4,12 +4,12 @@ import collections.abc
 import types
 import typing
 
-import amulet.version
-import amulet_nbt
+import amulet.core.version
+import amulet.nbt
 
-__all__ = ["Block", "BlockStack", "PropertyValueType"]
+__all__ = ["Block", "BlockStack"]
 
-class Block(amulet.version.PlatformVersionContainer):
+class Block(amulet.core.version.PlatformVersionContainer):
     """
     A class to manage the state of a block.
 
@@ -37,9 +37,16 @@ class Block(amulet.version.PlatformVersionContainer):
     >>> )
     """
 
+    PropertyValue: typing.ClassVar[typing.TypeAlias] = (
+        amulet.nbt.ByteTag
+        | amulet.nbt.ShortTag
+        | amulet.nbt.IntTag
+        | amulet.nbt.LongTag
+        | amulet.nbt.StringTag
+    )
     @staticmethod
     def from_bedrock_blockstate(
-        platform: str, version: amulet.version.VersionNumber, blockstate: str
+        platform: str, version: amulet.core.version.VersionNumber, blockstate: str
     ) -> Block:
         """
         Parse a Bedrock format blockstate where values are all strings and populate a :class:`Block` class with the data.
@@ -55,7 +62,7 @@ class Block(amulet.version.PlatformVersionContainer):
 
     @staticmethod
     def from_java_blockstate(
-        platform: str, version: amulet.version.VersionNumber, blockstate: str
+        platform: str, version: amulet.core.version.VersionNumber, blockstate: str
     ) -> Block:
         """
         Parse a Java format blockstate where values are all strings and populate a :class:`Block` class with the data.
@@ -79,16 +86,16 @@ class Block(amulet.version.PlatformVersionContainer):
     def __init__(
         self,
         platform: str,
-        version: amulet.version.VersionNumber,
+        version: amulet.core.version.VersionNumber,
         namespace: str,
         base_name: str,
         properties: dict[
             str,
-            amulet_nbt.ByteTag
-            | amulet_nbt.ShortTag
-            | amulet_nbt.IntTag
-            | amulet_nbt.LongTag
-            | amulet_nbt.StringTag,
+            amulet.nbt.ByteTag
+            | amulet.nbt.ShortTag
+            | amulet.nbt.IntTag
+            | amulet.nbt.LongTag
+            | amulet.nbt.StringTag,
         ] = {},
     ) -> None: ...
     def __le__(self, arg0: Block) -> bool: ...
@@ -170,11 +177,11 @@ class Block(amulet.version.PlatformVersionContainer):
         self,
     ) -> dict[
         str,
-        amulet_nbt.ByteTag
-        | amulet_nbt.ShortTag
-        | amulet_nbt.IntTag
-        | amulet_nbt.LongTag
-        | amulet_nbt.StringTag,
+        amulet.nbt.ByteTag
+        | amulet.nbt.ShortTag
+        | amulet.nbt.IntTag
+        | amulet.nbt.LongTag
+        | amulet.nbt.StringTag,
     ]:
         """
         The properties of the blockstate represented by the :class:`Block` object as a dictionary.
@@ -248,7 +255,7 @@ class BlockStack:
         """
 
     @property
-    def extra_blocks(self) -> tuple:
+    def extra_blocks(self) -> tuple[Block]:
         """
         The extra blocks in the stack.
 
@@ -261,11 +268,3 @@ class BlockStack:
 
         :return: A tuple of :class:`Block` objects
         """
-
-PropertyValueType: typing.TypeAlias = (
-    amulet_nbt.ByteTag
-    | amulet_nbt.ShortTag
-    | amulet_nbt.IntTag
-    | amulet_nbt.LongTag
-    | amulet_nbt.StringTag
-)

amulet/core/block/block.hpp

@@ -0,0 +1,156 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <variant>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/nbt/tag/int.hpp>
+#include <amulet/nbt/tag/string.hpp>
+
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+
+class Block : public PlatformVersionContainer {
+public:
+    using PropertyValue = std::variant<
+        Amulet::NBT::ByteTag,
+        Amulet::NBT::ShortTag,
+        Amulet::NBT::IntTag,
+        Amulet::NBT::LongTag,
+        Amulet::NBT::StringTag>;
+
+    using PropertyMap = std::map<std::string, PropertyValue>;
+
+private:
+    std::string _namespace;
+    std::string _base_name;
+    PropertyMap _properties;
+
+public:
+    const std::string& get_namespace() const { return _namespace; }
+    const std::string& get_base_name() const { return _base_name; }
+    const PropertyMap& get_properties() const { return _properties; }
+
+    template <
+        typename PlatformT,
+        typename VersionT,
+        typename NamespaceT,
+        typename BaseNameT>
+    Block(
+        PlatformT&& platform,
+        VersionT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+        , _properties()
+    {
+    }
+
+    template <
+        typename PlatformT,
+        typename VersionT,
+        typename NamespaceT,
+        typename BaseNameT,
+        typename PropertiesT>
+    Block(
+        PlatformT&& platform,
+        VersionT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name,
+        PropertiesT&& properties)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+        , _properties(std::forward<PropertiesT>(properties))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static Block deserialise(BinaryReader&);
+
+    auto operator<=>(const Block& other) const
+    {
+        auto cmp = PlatformVersionContainer::operator<=>(other);
+        if (cmp != 0) {
+            return cmp;
+        }
+        cmp = _namespace <=> other._namespace;
+        if (cmp != 0) {
+            return cmp;
+        }
+        cmp = _base_name <=> other._base_name;
+        if (cmp != 0) {
+            return cmp;
+        }
+        return _properties <=> other._properties;
+    }
+    bool operator==(const Block& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+
+    AMULET_CORE_EXPORT std::string java_blockstate() const;
+    AMULET_CORE_EXPORT std::string bedrock_blockstate() const;
+    AMULET_CORE_EXPORT static Block from_java_blockstate(const PlatformType&, const VersionNumber&, const std::string&);
+    AMULET_CORE_EXPORT static Block from_bedrock_blockstate(const PlatformType&, const VersionNumber&, const std::string&);
+};
+
+class BlockStack {
+private:
+    std::vector<Block> _blocks;
+
+public:
+    const std::vector<Block>& get_blocks() const { return _blocks; }
+
+    template <typename... Args>
+        requires std::is_constructible_v<std::vector<Block>, Args...>
+    BlockStack(Args&&... args)
+        : _blocks(std::forward<Args>(args)...)
+    {
+        if (_blocks.empty()) {
+            throw std::invalid_argument("A BlockStack must contain at least one block");
+        }
+    }
+
+    BlockStack(std::initializer_list<Block> blocks)
+        : _blocks(blocks)
+    {
+        if (_blocks.empty()) {
+            throw std::invalid_argument("A BlockStack must contain at least one block");
+        }
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockStack deserialise(BinaryReader&);
+
+    auto operator<=>(const BlockStack& other) const
+    {
+        auto cmp = size() <=> other.size();
+        if (cmp != 0) {
+            return cmp;
+        }
+        for (size_t i = 0; i < size(); i++) {
+            cmp = at(i) <=> other.at(i);
+            if (cmp != 0) {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+    bool operator==(const BlockStack& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+
+    size_t size() const { return _blocks.size(); }
+    const Block& at(size_t index) const { return _blocks.at(index); }
+};
+
+} // namespace Amulet

amulet/{block_entity.pyi → core/block_entity/__init__.pyi}

@@ -3,12 +3,12 @@ from __future__ import annotations
 import types
 import typing
 
-import amulet.version
-import amulet_nbt
+import amulet.core.version
+import amulet.nbt
 
 __all__ = ["BlockEntity"]
 
-class BlockEntity(amulet.version.PlatformVersionContainer):
+class BlockEntity(amulet.core.version.PlatformVersionContainer):
     """
     A class to contain all the data to define a BlockEntity.
     """
@@ -21,10 +21,10 @@ class BlockEntity(amulet.version.PlatformVersionContainer):
     def __init__(
         self,
         platform: str,
-        version: amulet.version.VersionNumber,
+        version: amulet.core.version.VersionNumber,
         namespace: str,
         base_name: str,
-        nbt: amulet_nbt.NamedTag,
+        nbt: amulet.nbt.NamedTag,
     ) -> None: ...
     def __repr__(self) -> str: ...
     @property
@@ -65,7 +65,7 @@ class BlockEntity(amulet.version.PlatformVersionContainer):
         """
 
     @property
-    def nbt(self) -> amulet_nbt.NamedTag:
+    def nbt(self) -> amulet.nbt.NamedTag:
         """
         The nbt data for the block entity.
         >>> block_entity: BlockEntity
@@ -75,4 +75,4 @@ class BlockEntity(amulet.version.PlatformVersionContainer):
         """
 
     @nbt.setter
-    def nbt(self, arg1: amulet_nbt.NamedTag) -> None: ...
+    def nbt(self, arg1: amulet.nbt.NamedTag) -> None: ...

amulet/core/block_entity/block_entity.hpp

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <variant>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/nbt/tag/eq.hpp>
+#include <amulet/nbt/tag/named_tag.hpp>
+
+#include <amulet/core/dll.hpp>
+#include <amulet/core/version/version.hpp>
+
+namespace Amulet {
+class BlockEntity : public PlatformVersionContainer {
+private:
+    std::string _namespace;
+    std::string _base_name;
+    std::shared_ptr<Amulet::NBT::NamedTag> _nbt;
+
+public:
+    const std::string& get_namespace() const
+    {
+        return _namespace;
+    }
+
+    template <typename NamespaceT>
+    void set_namespace(NamespaceT&& namespace_)
+    {
+        _namespace = std::forward<NamespaceT>(namespace_);
+    }
+
+    const std::string& get_base_name() const
+    {
+        return _base_name;
+    }
+
+    template <typename BaseNameT>
+    void set_base_name(BaseNameT&& base_name)
+    {
+        _base_name = std::forward<BaseNameT>(base_name);
+    }
+
+    std::shared_ptr<Amulet::NBT::NamedTag> get_nbt() const
+    {
+        return _nbt;
+    }
+
+    template <typename NBTT>
+    void set_nbt(NBTT&& nbt)
+    {
+        if constexpr (std::is_same_v<std::shared_ptr<Amulet::NBT::NamedTag>, std::decay_t<NBTT>>) {
+            _nbt = std::forward<NBTT>(nbt);
+        } else {
+            _nbt = std::make_shared<Amulet::NBT::NamedTag>(std::forward<NBTT>(nbt));
+        }
+    }
+
+    template <
+        typename PlatformT,
+        typename VersionNumberT,
+        typename NamespaceT,
+        typename BaseNameT>
+    BlockEntity(
+        PlatformT&& platform,
+        VersionNumberT&& version,
+        NamespaceT&& namespace_,
+        BaseNameT&& base_name,
+        std::shared_ptr<Amulet::NBT::NamedTag> nbt)
+        : PlatformVersionContainer(std::forward<PlatformT>(platform), std::forward<VersionNumberT>(version))
+        , _namespace(std::forward<NamespaceT>(namespace_))
+        , _base_name(std::forward<BaseNameT>(base_name))
+        , _nbt(std::move(nbt))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static BlockEntity deserialise(BinaryReader&);
+
+    AMULET_CORE_EXPORT bool operator==(const BlockEntity& other) const;
+};
+}

amulet/{errors.py → core/chunk/__init__.pyi}

@@ -1,23 +1,34 @@
-class DimensionDoesNotExist(Exception):
-    """An error thrown if trying to load data from a dimension that does not exist."""
+from __future__ import annotations
 
+from . import component
 
-class ChunkLoadError(Exception):
-    """
-    An error thrown if a chunk failed to load for some reason.
+__all__ = [
+    "Chunk",
+    "ChunkDoesNotExist",
+    "ChunkLoadError",
+    "component",
+    "get_null_chunk",
+]
 
-    This may be due to a corrupt chunk, an unsupported chunk format or just because the chunk does not exist to be loaded.
+class Chunk:
+    """
+    A base class for all chunk classes.
+    """
 
-    Catching this error will also catch :class:`ChunkDoesNotExist`
+    def reconstruct_chunk(self, arg0: dict[str, bytes | None]) -> None:
+        """
+        This is private. Do not use this. It will be removed in the future.
+        """
 
-    >>> 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.
-    """
+    def serialise_chunk(self) -> dict[str, bytes | None]:
+        """
+        This is private. Do not use this. It will be removed in the future.
+        """
 
+    @property
+    def chunk_id(self) -> str: ...
+    @property
+    def component_ids(self) -> set[str]: ...
 
 class ChunkDoesNotExist(ChunkLoadError):
     """
@@ -34,30 +45,23 @@ class ChunkDoesNotExist(ChunkLoadError):
     >>>     # 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 ChunkLoadError(RuntimeError):
     """
+    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.
 
-class LevelReadError(Exception):
-    """
-    An error thrown when the raw level data cannot be read from.
+    Catching this error will also catch :class:`ChunkDoesNotExist`
 
-    This is usually because the data has been opened somewhere else.
+    >>> 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 LevelWriteError(Exception):
+def get_null_chunk(arg0: str) -> Chunk:
     """
-    An error thrown when the raw level data cannot be written to.
-
-    This is usually because the data has been opened somewhere else.
+    This is a private function
     """