amulet-core 2.0a8__tar.gz → 2.0.1a0__tar.gz

amulet_core-2.0.1a0/CMakeLists.txt

@@ -0,0 +1,111 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(amulet_core LANGUAGES CXX)
+
+# Set C++20
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Set platform variables
+if (WIN32)
+	# set windows 7 as the minimum version
+	add_definitions(-D_WIN32_WINNT=0x0601)
+elseif(APPLE)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15")
+else()
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
+if (MSVC)
+    add_definitions("/MP")
+endif()
+
+include(FetchContent)
+
+# Add zlib
+set(ZLIB_BUILD_EXAMPLES OFF)
+FetchContent_Declare(
+  zlib
+  GIT_REPOSITORY https://github.com/madler/zlib.git
+  GIT_TAG        51b7f2abdade71cd9bb0e7a373ef2610ec6f9daf
+)
+FetchContent_MakeAvailable(zlib)
+set(ZLIB_ROOT ${zlib_SOURCE_DIR})
+set(ZLIB_USE_STATIC_LIBS ON)
+set(ZLIB_LIBRARY ${INSTALL_LIB_DIR})
+find_package(ZLIB REQUIRED)
+target_compile_definitions(zlibstatic PUBLIC ZLIB_CONST)
+
+# Add lz4
+FetchContent_Declare(
+  lz4
+  GIT_REPOSITORY https://github.com/lz4/lz4.git
+  GIT_TAG        ebb370ca83af193212df4dcbadcc5d87bc0de2f0
+)
+FetchContent_MakeAvailable(lz4)
+set(LZ4_BUILD_CLI OFF)
+add_subdirectory(${lz4_SOURCE_DIR}/build/cmake)
+
+# Add pybind11
+find_package(pybind11 CONFIG REQUIRED)
+
+# Add Amulet libraries
+find_package(amulet_pybind11_extensions CONFIG REQUIRED)
+find_package(amulet_io CONFIG REQUIRED)
+find_package(amulet_nbt CONFIG REQUIRED)
+
+# Find C++ files
+file(REAL_PATH src SOURCE_PATH)
+file(GLOB_RECURSE EXTENSION_SOURCES LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.py.cpp)
+file(GLOB_RECURSE EXTENSION_HEADERS LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.py.hpp)
+file(GLOB_RECURSE SOURCES LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.cpp)
+file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.hpp)
+list(REMOVE_ITEM SOURCES ${EXTENSION_SOURCES})
+list(REMOVE_ITEM HEADERS ${EXTENSION_HEADERS})
+
+# Add implementation
+add_library(amulet_core SHARED)
+target_link_libraries( amulet_core PRIVATE zlibstatic )
+target_link_libraries( amulet_core PRIVATE lz4_static )
+target_link_libraries( amulet_core PRIVATE amulet_io )
+target_link_libraries( amulet_core PRIVATE amulet_nbt )
+target_compile_definitions(amulet_core PRIVATE ExportAmuletCore)
+target_include_directories(amulet_core PUBLIC ${SOURCE_PATH})
+target_sources(amulet_core PRIVATE ${SOURCES} ${HEADERS})
+foreach(FILE ${SOURCES} ${HEADERS})
+    file(RELATIVE_PATH REL_PATH ${SOURCE_PATH} ${FILE})
+    get_filename_component(GROUP ${REL_PATH} DIRECTORY)
+    string(REPLACE "/" "\\" GROUP ${GROUP})
+    source_group(${GROUP} FILES ${FILE})
+endforeach()
+
+# Add python extension
+pybind11_add_module(_amulet_core)
+target_link_libraries( _amulet_core PRIVATE amulet_pybind11_extensions )
+target_link_libraries( _amulet_core PRIVATE amulet_io )
+target_link_libraries( _amulet_core PRIVATE amulet_nbt )
+target_link_libraries( _amulet_core PRIVATE amulet_core )
+target_compile_definitions(_amulet_core PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
+target_compile_definitions(_amulet_core PRIVATE PYBIND11_VERSION="${pybind11_VERSION}")
+target_compile_definitions(_amulet_core PRIVATE COMPILER_ID="${CMAKE_CXX_COMPILER_ID}")
+target_compile_definitions(_amulet_core PRIVATE COMPILER_VERSION="${CMAKE_CXX_COMPILER_VERSION}")
+target_sources(_amulet_core PRIVATE ${EXTENSION_SOURCES} ${EXTENSION_HEADERS})
+foreach(FILE ${EXTENSION_SOURCES} ${EXTENSION_HEADERS})
+    file(RELATIVE_PATH REL_PATH ${SOURCE_PATH} ${FILE})
+    get_filename_component(GROUP ${REL_PATH} DIRECTORY)
+    string(REPLACE "/" "\\" GROUP ${GROUP})
+    source_group(${GROUP} FILES ${FILE})
+endforeach()
+
+if(NOT DEFINED AMULET_CORE_EXT_DIR)
+    set(AMULET_CORE_EXT_DIR ${amulet_core_DIR})
+endif()
+
+# Install
+install(TARGETS amulet_core DESTINATION ${amulet_core_DIR})
+install(TARGETS _amulet_core DESTINATION ${AMULET_CORE_EXT_DIR})
+
+if (DEFINED BUILD_AMULET_CORE_TESTS)
+    add_subdirectory(tests)
+endif()

amulet_core-2.0.1a0/MANIFEST.in

@@ -0,0 +1,8 @@
+include build_requires.py
+include requirements.py
+
+recursive-include src/amulet *.cpp *.hpp *Config.cmake
+
+include CMakeLists.txt
+
+prune tests

{amulet_core-2.0a8/src/amulet_core.egg-info → amulet_core-2.0.1a0}/PKG-INFO

@@ -1,34 +1,39 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: amulet-core
-Version: 2.0a8
+Version: 2.0.1a0
 Summary: A Python library for reading/writing Minecraft's various save formats.
-Home-page: https://www.amuletmc.com
-Author: James Clare, Ben Gothard et al.
-Author-email: amuleteditor@gmail.com
-Platform: any
+Author: James Clare, Ben Gothard
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-Core
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-Core/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: amulet-compiler-target==1.0
 Requires-Dist: numpy~=2.0
-Requires-Dist: amulet-nbt~=4.0a6
-Requires-Dist: portalocker~=2.4
-Requires-Dist: amulet-leveldb~=1.0b0
-Requires-Dist: platformdirs~=3.1
-Requires-Dist: amulet-runtime-final~=1.1
-Requires-Dist: pillow~=10.0
-Requires-Dist: lz4~=4.3
+Requires-Dist: amulet-compiler-version==3.0.0
+Requires-Dist: amulet-io~=1.0
+Requires-Dist: amulet-nbt~=4.0.0.0a24
 Provides-Extra: docs
 Requires-Dist: Sphinx>=1.7.4; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints>=1.3.0; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=0.3.1; extra == "docs"
 Provides-Extra: dev
+Requires-Dist: setuptools>=42; extra == "dev"
+Requires-Dist: versioneer; extra == "dev"
+Requires-Dist: packaging; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pybind11[global]==2.13.6; extra == "dev"
+Requires-Dist: amulet_pybind11_extensions~=1.0; extra == "dev"
+Requires-Dist: pybind11_stubgen>=2.5.4; extra == "dev"
 Requires-Dist: black>=22.3; extra == "dev"
-Requires-Dist: pre_commit>=1.11.1; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: types-pyinstaller; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: autoflake; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-pyinstaller; extra == "dev"
+Requires-Dist: amulet-test-utils~=1.1; extra == "dev"
+Dynamic: requires-dist
 
 # Amulet Core
 

amulet_core-2.0.1a0/build_requires.py

@@ -0,0 +1,24 @@
+from typing import Union, Mapping
+import requirements
+
+from setuptools import build_meta
+from setuptools.build_meta import *
+
+
+def get_requires_for_build_wheel(
+    config_settings: Union[Mapping[str, Union[str, list[str], None]], None] = None,
+) -> list[str]:
+    return [
+        *build_meta.get_requires_for_build_wheel(config_settings),
+        "wheel",
+        *requirements.get_build_dependencies(),
+    ]
+
+
+def get_requires_for_build_editable(
+    config_settings: Union[Mapping[str, Union[str, list[str], None]], None] = None,
+) -> list[str]:
+    return [
+        *build_meta.get_requires_for_build_editable(config_settings),
+        *requirements.get_build_dependencies(),
+    ]

amulet_core-2.0.1a0/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "versioneer",
+    "packaging",
+    "amulet-compiler-version@git+https://github.com/Amulet-Team/Amulet-Compiler-Version.git@3.0"
+]
+build-backend = "build_requires"
+backend-path = [""]
+
+[project]
+name = "amulet-core"
+authors = [
+    {name = "James Clare"},
+    {name = "Ben Gothard"},
+]
+description = "A Python library for reading/writing Minecraft's various save formats."
+dynamic = ["version", "readme", "dependencies"]
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+docs = [
+    "Sphinx>=1.7.4",
+    "sphinx-autodoc-typehints>=1.3.0",
+    "sphinx_rtd_theme>=0.3.1",
+]
+dev = [
+    "setuptools>=42",
+    "versioneer",
+    "packaging",
+    "wheel",
+    "pybind11[global]==2.13.6",
+    "amulet_pybind11_extensions~=1.0",
+    "pybind11_stubgen>=2.5.4",
+    "black>=22.3",
+    "isort",
+    "autoflake",
+    "mypy",
+    "types-pyinstaller",
+    "amulet-test-utils~=1.1",
+]
+
+[project.urls]
+Homepage = "https://www.amuletmc.com"
+Repository = "https://github.com/Amulet-Team/Amulet-Core"
+Issues = "https://github.com/Amulet-Team/Amulet-Core/issues"
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.package-data]
+"*" = [
+    "*Config.cmake",
+    "**/*.hpp",
+    "**/*.dll",
+    "**/*.so",
+    "**/*.dylib",
+    "**/*.lib",
+]
+
+[tool.setuptools.dynamic]
+readme = {file = ["README.md"], content-type = "text/markdown"}
+
+[project.entry-points.pyinstaller40]
+hook-dirs = "amulet.core.__pyinstaller:get_hook_dirs"
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "src/amulet/core/_version.py"
+versionfile_build = "amulet/core/_version.py"
+tag_prefix = ""
+parentdir_prefix = "amulet-core-"

amulet_core-2.0.1a0/requirements.py

@@ -0,0 +1,70 @@
+import os
+import amulet_compiler_version
+from packaging.version import Version
+
+AMULET_COMPILER_TARGET_REQUIREMENT = "==1.0"
+AMULET_COMPILER_VERSION_REQUIREMENT = "==3.0.0"
+
+PYBIND11_REQUIREMENT = "==2.13.6"
+AMULET_PYBIND11_EXTENSIONS_REQUIREMENT = "~=1.0"
+
+AMULET_IO_REQUIREMENT = "~=1.0"
+# AMULET_NBT_REQUIREMENT = "~=4.0"
+AMULET_NBT_REQUIREMENT = "~=4.0.0.0a24"
+NUMPY_REQUIREMENT = "~=2.0"
+
+
+def get_specifier_set(version_str: str, compiler_suffix_: str = "") -> str:
+    """
+    version_str: The PEP 440 version number of the library.
+    compiler_suffix_: Only specified if it is a compiled library and the compiler is being frozen.
+    """
+    version = Version(version_str)
+    if version.epoch != 0 or version.is_devrelease or version.is_postrelease:
+        raise RuntimeError(f"Unsupported version format. {version_str}")
+
+    major, minor, patch, fix, *_ = version.release + (0, 0, 0, 0)
+
+    return f"~={major}.{minor}.{patch}.{fix}{compiler_suffix_}{''.join(map(str, version.pre or ()))}"
+
+
+if os.environ.get("AMULET_FREEZE_COMPILER", None):
+    AMULET_COMPILER_VERSION_REQUIREMENT = f"=={amulet_compiler_version.__version__}"
+
+    compiler_suffix = f".{'.'.join(amulet_compiler_version.__version__.split('.')[3:])}"
+
+    try:
+        import amulet.io
+    except ImportError:
+        pass
+    else:
+        AMULET_IO_REQUIREMENT = get_specifier_set(amulet.io.__version__)
+
+    try:
+        import amulet.nbt
+    except ImportError:
+        pass
+    else:
+        AMULET_NBT_REQUIREMENT = get_specifier_set(
+            amulet.nbt.__version__, compiler_suffix
+        )
+
+
+def get_build_dependencies() -> list:
+    return [
+        f"pybind11{PYBIND11_REQUIREMENT}",
+        f"amulet_pybind11_extensions{AMULET_PYBIND11_EXTENSIONS_REQUIREMENT}",
+        f"amulet_nbt{AMULET_NBT_REQUIREMENT}",
+        f"amulet_io{AMULET_IO_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+    ]
+
+
+def get_runtime_dependencies() -> list[str]:
+    return [
+        f"amulet-compiler-target{AMULET_COMPILER_TARGET_REQUIREMENT}",
+        f"numpy{NUMPY_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+        f"amulet-io{AMULET_IO_REQUIREMENT}",
+        f"amulet-nbt{AMULET_NBT_REQUIREMENT}",
+    ]

amulet_core-2.0.1a0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

amulet_core-2.0.1a0/setup.py

@@ -0,0 +1,108 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import setup, Extension, Command
+from setuptools.command.build_ext import build_ext
+
+from packaging.version import Version
+
+import versioneer
+
+import requirements
+import amulet_compiler_version
+
+
+def fix_path(path: str) -> str:
+    return os.path.realpath(path).replace(os.sep, "/")
+
+
+dependencies = requirements.get_runtime_dependencies()
+
+cmdclass: dict[str, type[Command]] = versioneer.get_cmdclass()
+
+
+class CMakeBuild(cmdclass.get("build_ext", build_ext)):
+    def build_extension(self, ext):
+        import pybind11
+        import amulet.pybind11_extensions
+        import amulet.io
+        import amulet.nbt
+
+        ext_dir = (
+            (Path.cwd() / self.get_ext_fullpath("")).parent.resolve()
+            / "amulet"
+            / "core"
+        )
+        core_src_dir = (
+            Path.cwd() / "src" / "amulet" / "core" if self.editable_mode else ext_dir
+        )
+
+        platform_args = []
+        if sys.platform == "win32":
+            platform_args.extend(["-G", "Visual Studio 17 2022"])
+            if sys.maxsize > 2**32:
+                platform_args.extend(["-A", "x64"])
+            else:
+                platform_args.extend(["-A", "Win32"])
+            platform_args.extend(["-T", "v143"])
+
+        if subprocess.run(
+            [
+                "cmake",
+                *platform_args,
+                f"-DPYTHON_EXECUTABLE={sys.executable}",
+                f"-Dpybind11_DIR={pybind11.get_cmake_dir().replace(os.sep, '/')}",
+                f"-Damulet_pybind11_extensions_DIR={fix_path(amulet.pybind11_extensions.__path__[0])}",
+                f"-Damulet_io_DIR={fix_path(amulet.io.__path__[0])}",
+                f"-Damulet_nbt_DIR={fix_path(amulet.nbt.__path__[0])}",
+                f"-Damulet_core_DIR={fix_path(core_src_dir)}",
+                f"-DAMULET_CORE_EXT_DIR={fix_path(ext_dir)}",
+                f"-DCMAKE_INSTALL_PREFIX=install",
+                "-B",
+                "build",
+            ]
+        ).returncode:
+            raise RuntimeError("Error configuring amulet_core")
+        if subprocess.run(
+            ["cmake", "--build", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_core")
+        if subprocess.run(
+            ["cmake", "--install", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_core")
+
+
+cmdclass["build_ext"] = CMakeBuild
+
+
+def _get_version() -> str:
+    version_str: str = versioneer.get_version()
+
+    if os.environ.get("AMULET_FREEZE_COMPILER", None):
+        # Add the compiler version to the library version so that pip sees it as a distinct version.
+        compiler_version_str = ".".join(
+            amulet_compiler_version.__version__.split(".")[3:]
+        )
+        if compiler_version_str:
+            version = Version(version_str)
+            if version.epoch != 0 or version.is_devrelease or version.is_postrelease:
+                raise RuntimeError(f"Unsupported version format. {version_str}")
+            major, minor, patch, fix, *_ = version.release + (0, 0, 0, 0)
+            pre = "".join(map(str, version.pre)) if version.is_prerelease else ""
+            local = f"+{version.local}" if version.local else ""
+            version_str = (
+                f"{major}.{minor}.{patch}.{fix}.{compiler_version_str}{pre}{local}"
+            )
+
+    return version_str
+
+
+setup(
+    version=_get_version(),
+    cmdclass=cmdclass,
+    ext_modules=[Extension("amulet.core._amulet_core", [])],
+    install_requires=dependencies,
+)

amulet_core-2.0.1a0/src/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-2.0.1a0/src/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-2.0.1a0/src/amulet/core/_amulet_core.py.cpp

@@ -0,0 +1,40 @@
+#include <pybind11/pybind11.h>
+
+#include <amulet/pybind11_extensions/compatibility.hpp>
+#include <amulet/pybind11_extensions/py_module.hpp>
+
+namespace py = pybind11;
+namespace pyext = Amulet::pybind11_extensions;
+
+void init_version(py::module);
+void init_selection(py::module);
+void init_block(py::module);
+void init_block_entity(py::module);
+void init_entity(py::module);
+void init_biome(py::module);
+void init_palette(py::module);
+void init_chunk(py::module);
+
+void init_module(py::module m)
+{
+    pyext::init_compiler_config(m);
+    pyext::check_compatibility(py::module::import("amulet.nbt"), m);
+
+    // Submodules
+    init_version(m);
+    init_selection(m);
+    init_block(m);
+    init_block_entity(m);
+    init_entity(m);
+    init_biome(m);
+    init_palette(m);
+    init_chunk(m);
+}
+
+PYBIND11_MODULE(_amulet_core, m)
+{
+    py::options options;
+    options.disable_function_signatures();
+    m.def("init", &init_module, py::doc("init(arg0: types.ModuleType) -> None"));
+    options.enable_function_signatures();
+}

amulet_core-2.0.1a0/src/amulet/core/_amulet_core.pyi

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

{amulet_core-2.0a8/src/amulet → amulet_core-2.0.1a0/src/amulet/core}/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-27T10:30:17+0000",
+ "date": "2025-05-28T10:06:43+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "7844bec50b93c8711ae703840b1a0e43b8283df6",
- "version": "2.0a8"
+ "full-revisionid": "25debe9d8c82b3c964e68035a723bed4a6f2e2e4",
+ "version": "2.0.1a0"
 }
 '''  # END VERSION_JSON
 

amulet_core-2.0.1a0/src/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_core-2.0a8/src/amulet/biome.pyi → amulet_core-2.0.1a0/src/amulet/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-2.0.1a0/src/amulet/core/biome/biome.cpp

@@ -0,0 +1,41 @@
+#include <functional>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <variant>
+
+#include <amulet/core/dll.hpp>
+#include <amulet/nbt/nbt_encoding/binary.hpp>
+#include <amulet/nbt/nbt_encoding/string.hpp>
+
+#include "biome.hpp"
+
+namespace Amulet {
+
+void Biome::serialise(BinaryWriter& writer) const
+{
+    writer.write_numeric<std::uint8_t>(1);
+    writer.write_size_and_bytes(get_platform());
+    get_version().serialise(writer);
+    writer.write_size_and_bytes(_namespace);
+    writer.write_size_and_bytes(_base_name);
+}
+
+Biome Biome::deserialise(BinaryReader& reader)
+{
+    auto version_number = reader.read_numeric<std::uint8_t>();
+    switch (version_number) {
+    case 1: {
+        std::string platform { reader.read_size_and_bytes() };
+        VersionNumber version = VersionNumber::deserialise(reader);
+        std::string namespace_ { reader.read_size_and_bytes() };
+        std::string base_name { reader.read_size_and_bytes() };
+        return { platform, version, namespace_, base_name };
+    }
+    default:
+        throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
+    }
+}
+
+}