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

amulet/core/version/version.hpp

@@ -0,0 +1,204 @@
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+typedef std::string PlatformType;
+
+// This class is designed to store semantic versions and data versions and allow comparisons between them.
+// It is a wrapper around std::vector<std::int64_t> with special comparison handling.
+// The version can contain zero to max(int64) values.
+// Undefined trailing values are implied zeros. 1.1 == 1.1.0
+// All methods are thread safe.
+class VersionNumber {
+private:
+    std::vector<std::int64_t> _vec;
+
+public:
+    // Get the underlying vector.
+    // Thread safe.
+    const std::vector<std::int64_t>& get_vector() const { return _vec; }
+
+    // Constructors
+    template <typename... Args>
+        requires std::is_constructible_v<std::vector<std::int64_t>, Args...>
+    VersionNumber(Args&&... args)
+        : _vec(std::forward<Args>(args)...)
+    {
+    }
+
+    VersionNumber(std::initializer_list<std::int64_t> args)
+        : _vec(args)
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionNumber deserialise(BinaryReader&);
+
+    // Iterators
+    std::vector<std::int64_t>::const_iterator begin() const { return _vec.begin(); }
+    std::vector<std::int64_t>::const_iterator end() const { return _vec.end(); }
+    std::vector<std::int64_t>::const_reverse_iterator rbegin() const { return _vec.rbegin(); }
+    std::vector<std::int64_t>::const_reverse_iterator rend() const { return _vec.rend(); }
+
+    // Capacity
+    size_t size() const { return _vec.size(); }
+
+    // Element access
+    std::int64_t operator[](size_t index) const {
+        if (index >= _vec.size()) {
+            return 0;
+        }
+        return _vec[index];
+    }
+
+    // Comparison
+    auto operator<=>(const VersionNumber& other) const
+    {
+        size_t max_len = std::max(_vec.size(), other.size());
+        std::int64_t v1, v2;
+        for (size_t i = 0; i < max_len; i++) {
+            v1 = (*this)[i];
+            v2 = other[i];
+            if (v1 < v2) {
+                // Less than
+                return std::strong_ordering::less;
+            }
+            if (v1 > v2) {
+                // Greater than
+                return std::strong_ordering::greater;
+            }
+        }
+        // equal
+        return std::strong_ordering::equal;
+    }
+    bool operator==(const VersionNumber& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+
+    // Convert the value to its string representation eg "1.1"
+    AMULET_CORE_EXPORT std::string toString() const;
+
+    // The version number with trailing zeros cut off.
+    AMULET_CORE_EXPORT std::vector<std::int64_t> cropped_version() const;
+
+    // Get the version number cropped or padded with zeros to the given length.
+    AMULET_CORE_EXPORT std::vector<std::int64_t> padded_version(size_t len) const;
+};
+
+// A class storing platform identifier and version number.
+// Thread safe.
+class PlatformVersionContainer {
+private:
+    PlatformType _platform;
+    VersionNumber _version;
+
+public:
+    // Get the platform identifier.
+    const PlatformType& get_platform() const { return _platform; }
+
+    // Get the version number.
+    const VersionNumber& get_version() const { return _version; }
+
+    template <typename PlatformT, typename VersionNumberT>
+    PlatformVersionContainer(
+        PlatformT&& platform,
+        VersionNumberT&& version)
+        : _platform(std::forward<PlatformT>(platform))
+        , _version(std::forward<VersionNumberT>(version))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static PlatformVersionContainer deserialise(BinaryReader&);
+
+    // Comparison operators
+    auto operator<=>(const PlatformVersionContainer& other) const
+    {
+        auto cmp = _platform <=> other._platform;
+        if (cmp != 0) {
+            return cmp;
+        }
+        return _version <=> other._version;
+    }
+    bool operator==(const PlatformVersionContainer& other) const
+    {
+        return (*this <=> other) == 0;
+    }
+};
+
+// A class storing platform identifier and minimum and maximum version numbers.
+// Thread safe.
+class VersionRange {
+private:
+    PlatformType _platform;
+    VersionNumber _min_version;
+    VersionNumber _max_version;
+
+public:
+    // Get the platform identifier.
+    const PlatformType& get_platform() const { return _platform; }
+
+    // Get the minimum version number
+    const VersionNumber& get_min_version() const { return _min_version; }
+
+    // Get the maximum version number
+    const VersionNumber& get_max_version() const { return _max_version; }
+
+    template <typename PlatformT, typename MinVersionT, typename MaxVersionT>
+    VersionRange(
+        PlatformT&& platform,
+        MinVersionT&& min_version,
+        MaxVersionT&& max_version)
+        : _platform(std::forward<PlatformT>(platform))
+        , _min_version(std::forward<MinVersionT>(min_version))
+        , _max_version(std::forward<MaxVersionT>(max_version))
+    {
+        if (_min_version > _max_version) {
+            throw std::invalid_argument("min_version must be less than or equal to max_version");
+        }
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionRange deserialise(BinaryReader&);
+
+    // Check if the platform is equal and the version number is within the range.
+    AMULET_CORE_EXPORT bool contains(const PlatformType& platform_, const VersionNumber& version) const;
+
+    // Equality operator
+    AMULET_CORE_EXPORT bool operator==(const VersionRange&) const;
+};
+
+// A class that contains a version range.
+class VersionRangeContainer {
+private:
+    VersionRange _version_range;
+
+public:
+    // Get the version range.
+    const VersionRange& get_version_range() const { return _version_range; }
+
+    template <typename VersionRangeT>
+    VersionRangeContainer(
+        VersionRangeT&& version_range)
+        : _version_range(std::forward<VersionRangeT>(version_range))
+    {
+    }
+
+    AMULET_CORE_EXPORT void serialise(BinaryWriter&) const;
+    AMULET_CORE_EXPORT static VersionRangeContainer deserialise(BinaryReader&);
+};
+}

{amulet_core-2.0a8.dist-info → amulet_core-2.0.1a2.post250529084747.dist-info}/METADATA

@@ -1,34 +1,39 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: amulet-core
-Version: 2.0a8
+Version: 2.0.1a2.post250529084747
 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.1297307203.19.43.34808.0
+Requires-Dist: amulet-io~=1.0.0.0
+Requires-Dist: amulet-nbt~=4.0.1.0a0
+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"
-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"
+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.1a2.post250529084747.dist-info/RECORD

@@ -0,0 +1,45 @@
+amulet/core/__init__.py,sha256=pfhPDVh2laUpJHVmUkoeX-q1P4szpIOsNoL0FdoVCu4,915
+amulet/core/_amulet_core.cp312-win_amd64.pyd,sha256=FYTlJOVb8Ouiu0Z4IaN-qg-JjMx9G_LZRvoL6DMyr5M,706048
+amulet/core/_amulet_core.pyi,sha256=6KCygVcKCdfcpjegv7RMDgxKh9M6F-IHNhPUNGZAlyQ,123
+amulet/core/_version.py,sha256=LOsO2jEJpBFjQ0jJMa7Osk2aXytWMaRadcNZlFee3J0,520
+amulet/core/amulet_core.dll,sha256=OpYu3qxBongNdMBx57aB05fcxL9Cx3u6SPiD1h_6MtQ,143360
+amulet/core/amulet_core.lib,sha256=RzD5dY_lZknOz5evjmGdALVddMiCEBjq_mBPWOhYmu8,45026
+amulet/core/amulet_coreConfig.cmake,sha256=eCpbb2Z3J1mDKeDwZGHf7LqsflWwJaYiDN-Fda_TmEc,714
+amulet/core/dll.hpp,sha256=pyhd9lh570R1Qi7TPPnKoiB-fAFmQan8Vnk-oZmuK70,586
+amulet/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amulet/core/__pyinstaller/__init__.py,sha256=vNM3T3GSrs58ywzILHdIsQP2sglKq6Jn4qwCGC3CZVQ,56
+amulet/core/__pyinstaller/hook-amulet.core.py,sha256=AmV845T4BRjex63_T_KCeKLUlV0DxEk6aWsUJaLqyGE,172
+amulet/core/biome/__init__.pyi,sha256=rRxGRmd4vq1BlYysmo0SdRYEVzNzyGTbn_hpRHrrdIk,2157
+amulet/core/biome/biome.hpp,sha256=6RftLCHa4jVLr3lmRU8RIuA4K5REU-1J8SmJts7Ty0Y,1539
+amulet/core/block/__init__.pyi,sha256=BMiVVmYDzFABg-Y5I0T7YcmLZRK8N-AL2YCcFD7Ue8w,9592
+amulet/core/block/block.hpp,sha256=iRZyFKwfM7tbiXaHN6MNZeedpVr8SZkkKPPm20Tkgbo,4702
+amulet/core/block_entity/__init__.pyi,sha256=95L-jlRnn4hTin13m_7f72M0uFkP4DQNE1T1PsA3eys,2159
+amulet/core/block_entity/block_entity.hpp,sha256=q_8rzz4JCQ-L4q025G-ooQ2G47Hf6hyn3Wou4GZZ1Dc,2277
+amulet/core/chunk/__init__.pyi,sha256=3CXjNyVx1FXuUeAZ0MdQgwPeFMY_63incYHG3IQxwqY,1946
+amulet/core/chunk/chunk.hpp,sha256=r3s5nPd60XwTyulG8xA7VdPH72OwDFwD-32faKp75ds,3915
+amulet/core/chunk/component/__init__.pyi,sha256=stjIjJy7yTVxicTbxsUh6H_57BvHRiNexqTWA0khlyQ,450
+amulet/core/chunk/component/biome_3d_component.hpp,sha256=Dx-16Qg1LsGSvxDSN7PmBpDvaUnXMzKEYAFPshuQmvw,3138
+amulet/core/chunk/component/block_component.hpp,sha256=JFk1O1IBWWX9-blvQN0Kv1xNUuWYWpMxkPB6jzIoG2w,3361
+amulet/core/chunk/component/block_component.pyi,sha256=Yn19Tm9S-ekqXJGcwOMBe3fiAgvZDT7GkVvBHjhdaIY,839
+amulet/core/chunk/component/block_entity_component.hpp,sha256=wCv7Im03GqPoTLmtt0bmvxrS12kJN_qjzqONuRZ2YmE,3918
+amulet/core/chunk/component/section_array_map.hpp,sha256=V_WAG56rz3SAUWMMLgoPAhY3faH3t4Egg9_PsSERueE,3855
+amulet/core/chunk/component/section_array_map.pyi,sha256=8Ws6Amv9WlDkJh-_WDY5ruT2IHaupnUo6jsnywbdtqs,2718
+amulet/core/entity/__init__.pyi,sha256=YNHd5CO245N678jRMkIRryt8BmMqwVqIglEx0UZ77VQ,2573
+amulet/core/entity/entity.hpp,sha256=02TsWsA2XNmULM92lx0Wby-exVur4Myncu_IY_a2KQ4,2911
+amulet/core/palette/__init__.pyi,sha256=_QLcDg5WSp-Y67CAUoa-EmA6zptftMvJtX8FfeDZJM8,284
+amulet/core/palette/biome_palette.hpp,sha256=V4OWp4TpLu0rXnyFM-UyP5rFzWhmtqP5MWbDjQC0nX8,2033
+amulet/core/palette/biome_palette.pyi,sha256=vcQahmsRxVy0Y2J96Wk5is0t4FSUiRBZ6V5buSGwsSs,1652
+amulet/core/palette/block_palette.hpp,sha256=e_LLR444vkbMO3KR5xhx0scIcgfd1HqEKyMiwqXqheY,2307
+amulet/core/palette/block_palette.pyi,sha256=dkNqcDYFHVQ8hKzEe48pa4SNlfQbvwWMwxVVYr4s09g,1779
+amulet/core/selection/__init__.pyi,sha256=STDthuVyAmuNrLp_uCvy-Nn54k8dzKZV1d0jM_KHu4g,238
+amulet/core/selection/box.hpp,sha256=WfQiXqRMSbaaxnVhpfdP4VzDhSIx3mnnakoGrZKv2aQ,3031
+amulet/core/selection/box.pyi,sha256=wwHCJAjZYmR_cKfOBWmmdggq5sHZO5R4bGuWp2GWvM0,6426
+amulet/core/selection/group.hpp,sha256=xK07faXoiVePn9v7sJ_oZJfie3lqgzcOuGkdRe4BsUA,2292
+amulet/core/selection/group.pyi,sha256=0dbn4ZCh7D2PFhzLbGuuS1Mr_WIo-sWtugxe4grWB8s,6401
+amulet/core/version/__init__.pyi,sha256=0-2azYaixOPPVeXGGy_JKZTeFHy6IP6z-hgfZ3WaxWs,4104
+amulet/core/version/version.hpp,sha256=yVc_uhBgmHQ0Evo73rXXoRwSQMHakUQxSYR3_fu2KH4,6506
+amulet_core-2.0.1a2.post250529084747.dist-info/METADATA,sha256=aDMkeKGcMNCCRmP46MgzGgactRy2-AouZgy3GqgBdtw,5013
+amulet_core-2.0.1a2.post250529084747.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+amulet_core-2.0.1a2.post250529084747.dist-info/entry_points.txt,sha256=a64mqk_dgbzVyk-pz0WKpK6kNAhIGdVT9DO2VqDIAc8,68
+amulet_core-2.0.1a2.post250529084747.dist-info/top_level.txt,sha256=3ZqHzNDiIb9kV8TwSeeXxK_9haSrsu631Qe4ndDo0rc,7
+amulet_core-2.0.1a2.post250529084747.dist-info/RECORD,,

{amulet_core-2.0a8.dist-info → amulet_core-2.0.1a2.post250529084747.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64
 

amulet_core-2.0.1a2.post250529084747.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pyinstaller40]
+hook-dirs = amulet.core.__pyinstaller:get_hook_dirs

amulet/__init__.py.cpp

@@ -1,45 +0,0 @@
-#include <pybind11/pybind11.h>
-namespace py = pybind11;
-
-void init_collections(py::module);
-void init_utils(py::module);
-void init_version(py::module);
-void init_block(py::module);
-void init_block_entity(py::module);
-void init_biome(py::module);
-void init_palette(py::module);
-void init_chunk(py::module);
-void init_chunk_components(py::module);
-void init_level(py::module);
-void init_block_mesh(py::module);
-
-static bool init_run = false;
-
-void init_amulet(py::module m){
-    if (init_run){ return; }
-    init_run = true;
-
-    // This is normally added after initilsation but we need it to pass to subpackages.
-    // This may cause issues with frozen installs.
-    m.attr("__path__") = py::module::import("importlib.util").attr("find_spec")("amulet").attr("submodule_search_locations");
-
-    py::module::import("amulet_nbt");
-
-    py::module::import("amulet._init").attr("init")(m);
-
-    // Submodules
-    init_collections(m);
-    init_utils(m);
-    init_version(m);
-    init_block(m);
-    init_block_entity(m);
-    init_biome(m);
-    init_palette(m);
-    init_chunk(m);
-    init_chunk_components(m);
-    init_level(m);
-    init_block_mesh(m);
-}
-
-PYBIND11_MODULE(__init__, m) { init_amulet(m); }
-PYBIND11_MODULE(amulet, m) { init_amulet(m); }

amulet/__init__.pyi

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from . import (
-    biome,
-    block,
-    block_entity,
-    chunk,
-    chunk_components,
-    collections,
-    level,
-    mesh,
-    palette,
-    utils,
-    version,
-)
-
-__all__ = [
-    "biome",
-    "block",
-    "block_entity",
-    "chunk",
-    "chunk_components",
-    "collections",
-    "level",
-    "mesh",
-    "palette",
-    "utils",
-    "version",
-]
-__version__: str

amulet/__pyinstaller/hook-amulet.py

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

amulet/_init.py

@@ -1,26 +0,0 @@
-from typing import Any
-
-
-def init(m: Any) -> None:
-    import os
-    import logging
-    import platformdirs
-
-    from ._version import get_versions
-
-    m.__version__ = get_versions()["version"]
-
-    # m.entity_support = False
-
-    # Initialise default paths. Applications should override these environment variables.
-    # os.environ.setdefault("DATA_DIR", platformdirs.user_data_dir("AmuletTeam", "AmuletTeam"))
-    # os.environ.setdefault("CONFIG_DIR", platformdirs.user_config_dir("AmuletTeam", "AmuletTeam"))
-    os.environ.setdefault(
-        "CACHE_DIR", platformdirs.user_cache_dir("AmuletTeam", "AmuletTeam")
-    )
-    os.environ.setdefault(
-        "LOG_DIR", platformdirs.user_log_dir("AmuletTeam", "AmuletTeam")
-    )
-
-    # init a default logger
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")

amulet/biome.cpp

@@ -1,36 +0,0 @@
-#include <map>
-#include <variant>
-#include <type_traits>
-#include <string>
-#include <functional>
-#include <stdexcept>
-
-#include <amulet/biome.hpp>
-#include <amulet_nbt/nbt_encoding/binary.hpp>
-#include <amulet_nbt/nbt_encoding/string.hpp>
-
-namespace Amulet {
-    void Biome::serialise(BinaryWriter& writer) const {
-        writer.writeNumeric<std::uint8_t>(1);
-        writer.writeSizeAndBytes(get_platform());
-        get_version()->serialise(writer);
-        writer.writeSizeAndBytes(namespace_);
-        writer.writeSizeAndBytes(base_name);
-    }
-    std::shared_ptr<Biome> Biome::deserialise(BinaryReader& reader){
-        auto version_number = reader.readNumeric<std::uint8_t>();
-        switch (version_number) {
-        case 1:
-        {
-            std::string platform = reader.readSizeAndBytes();
-            std::shared_ptr<VersionNumber> version = VersionNumber::deserialise(reader);
-            std::string namespace_ = reader.readSizeAndBytes();
-            std::string base_name = reader.readSizeAndBytes();
-            return std::make_shared<Biome>(platform, version, namespace_, base_name);
-        }
-        default:
-            throw std::invalid_argument("Unsupported version " + std::to_string(version_number));
-        }
-    }
-
-}

amulet/biome.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include <amulet/version.hpp>
-#include <amulet/io/binary_reader.hpp>
-#include <amulet/io/binary_writer.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; }
-
-            Biome(
-                const PlatformType& platform,
-                std::shared_ptr<VersionNumber> version,
-                const std::string& namespace_,
-                const std::string& base_name
-            ):
-                PlatformVersionContainer(platform, version),
-                namespace_(namespace_),
-                base_name(base_name) {}
-
-            void serialise(BinaryWriter&) const;
-            static std::shared_ptr<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/biome.py.cpp

@@ -1,122 +0,0 @@
-#include <span>
-#include <memory>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/operators.h>
-#include <pybind11/typing.h>
-
-#include <amulet/biome.hpp>
-#include <amulet/collections/eq.py.hpp>
-
-namespace py = pybind11;
-
-void init_biome(py::module m_parent) {
-    auto m = m_parent.def_submodule("biome");
-    py::class_<Amulet::Biome, Amulet::PlatformVersionContainer, std::shared_ptr<Amulet::Biome>> Biome(m, "Biome",
-        "A class to manage the state of a biome.\n"
-        "\n"
-        "It is an immutable object that contains the platform, version, namespace and base name.\n"
-        "\n"
-        "Here's a few examples on how create a Biome object:\n"
-        "\n"
-        ">>> # Create a plains biome for Java 1.20.2\n"
-        ">>> plains = Biome(\"java\", VersionNumber(3578), \"minecraft\", \"plains\")\n"
-        ">>> # The version number for Java is the Java data version\n"
-        "\n"
-        ">>> # Create a plains biome for Bedrock \n"
-        ">>> plains = Biome(\"bedrock\", VersionNumber(1, 21, 0, 3), \"minecraft\", \"plains\")\n"
-        ">>> # The biome version number is unused in Bedrock but it is here for completeness."
-    );
-        Biome.def(
-            py::init<
-                const Amulet::PlatformType&,
-                std::shared_ptr<Amulet::VersionNumber>,
-                const std::string&,
-                const std::string&
-            >(),
-            py::arg("platform"),
-            py::arg("version"),
-            py::arg("namespace"),
-            py::arg("base_name")
-        );
-        Biome.def_property_readonly(
-            "namespaced_name",
-            [](const Amulet::Biome& self) {
-                return self.get_namespace() + ":" + self.get_base_name();
-            },
-            py::doc(
-                "The namespaced id of the :class:`Biome` object.\n"
-                "\n"
-                ">>> biome: Biome\n"
-                ">>> biome.namespaced_name\n"
-                "\n"
-                ":return: The \"namespace:base_name\" of the biome"
-            )
-        );
-        Biome.def_property_readonly(
-            "namespace",
-            &Amulet::Biome::get_namespace,
-            py::doc(
-                "The namespace of the :class:`Biome` object.\n"
-                "\n"
-                ">>> biome: Biome\n"
-                ">>> water.namespace\n"
-                "\n"
-                ":return: The namespace of the biome"
-            )
-        );
-        Biome.def_property_readonly(
-            "base_name",
-            &Amulet::Biome::get_base_name,
-            py::doc(
-                "The base name of the :class:`Biome` object.\n"
-                "\n"
-                ">>> biome: Biome\n"
-                ">>> biome.base_name\n"
-                "\n"
-                ":return: The base name of the biome"
-            )
-        );
-        Biome.def(
-            "__repr__",
-            [](const Amulet::Biome& self){
-                return "Biome(" +
-                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_version())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_namespace())).cast<std::string>() + ", " +
-                    py::repr(py::cast(self.get_base_name())).cast<std::string>() +
-                ")";
-            }
-        );
-        Biome.def(
-            "__hash__",
-            [](const Amulet::Biome& self) {
-                return py::hash(
-                    py::make_tuple(
-                        py::cast(self.get_platform()),
-                        py::cast(self.get_version()),
-                        py::cast(self.get_namespace()),
-                        py::cast(self.get_base_name())
-                    )
-                );
-            }
-        );
-        Biome.def(
-            py::pickle(
-                [](const Amulet::Biome& self) -> py::bytes {
-                    return py::bytes(Amulet::serialise(self));
-                },
-                [](py::bytes state){
-                    return Amulet::deserialise<Amulet::Biome>(state.cast<std::string>());
-                }
-            )
-        );
-
-        Eq(Biome);
-        Eq_default(Biome);
-        Biome.def(py::self > py::self);
-        Biome.def(py::self < py::self);
-        Biome.def(py::self >= py::self);
-        Biome.def(py::self <= py::self);
-}