amulet-anvil 1.0.0a0__tar.gz

amulet_anvil-1.0.0a0/CMakeLists.txt

@@ -0,0 +1,98 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(amulet_anvil 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 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_nbt CONFIG REQUIRED)
+find_package(amulet_core CONFIG REQUIRED)
+find_package(amulet_utils CONFIG REQUIRED)
+find_package(amulet_zlib 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_anvil SHARED)
+target_compile_definitions(amulet_anvil PRIVATE ExportAmuletAnvil)
+target_link_libraries( amulet_anvil PRIVATE lz4_static )
+target_link_libraries( amulet_anvil PRIVATE amulet_zlib )
+target_link_libraries( amulet_anvil PUBLIC amulet_nbt )
+target_link_libraries( amulet_anvil PUBLIC amulet_core )
+target_link_libraries( amulet_anvil PUBLIC amulet_utils )
+target_include_directories(amulet_anvil PUBLIC ${SOURCE_PATH})
+target_sources(amulet_anvil 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_anvil)
+target_link_libraries( _amulet_anvil PRIVATE amulet_pybind11_extensions )
+target_link_libraries( _amulet_anvil PRIVATE amulet_anvil )
+target_compile_definitions(_amulet_anvil PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
+target_compile_definitions(_amulet_anvil PRIVATE PYBIND11_VERSION="${pybind11_VERSION}")
+target_compile_definitions(_amulet_anvil PRIVATE COMPILER_ID="${CMAKE_CXX_COMPILER_ID}")
+target_compile_definitions(_amulet_anvil PRIVATE COMPILER_VERSION="${CMAKE_CXX_COMPILER_VERSION}")
+target_sources(_amulet_anvil 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_ANVIL_EXT_DIR)
+    set(AMULET_ANVIL_EXT_DIR ${amulet_anvil_DIR})
+endif()
+
+# Install
+install(TARGETS amulet_anvil DESTINATION ${amulet_anvil_DIR})
+install(TARGETS _amulet_anvil DESTINATION ${AMULET_ANVIL_EXT_DIR})
+
+if (DEFINED BUILD_AMULET_ANVIL_TESTS)
+    add_subdirectory(tests)
+endif()

amulet_anvil-1.0.0a0/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_anvil-1.0.0a0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: amulet-anvil
+Version: 1.0.0a0
+Summary: A C++ library with Python wrapper for the Minecraft Anvil format.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-Anvil
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-Anvil/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pybind11==2.13.6
+Requires-Dist: amulet-compiler-target==1.0
+Requires-Dist: amulet-compiler-version==3.0.0
+Requires-Dist: amulet-zlib~=1.0.0.0a1
+Requires-Dist: amulet-nbt~=5.0.0.0a1
+Requires-Dist: amulet-core~=2.0.2.0a1
+Requires-Dist: amulet-utils~=1.1.0.0a2
+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: 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: 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 Anvil
+
+A C++ library with Python wrapper for the Minecraft Anvil format.

amulet_anvil-1.0.0a0/README.md

@@ -0,0 +1,3 @@
+# Amulet Anvil
+
+A C++ library with Python wrapper for the Minecraft Anvil format.

amulet_anvil-1.0.0a0/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_anvil-1.0.0a0/pyproject.toml

@@ -0,0 +1,70 @@
+[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-anvil"
+authors = [
+    {name = "James Clare"},
+]
+description = "A C++ library with Python wrapper for the Minecraft Anvil format."
+dynamic = ["version", "readme", "dependencies"]
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+dev = [
+    "setuptools>=42",
+    "versioneer",
+    "packaging",
+    "wheel",
+    "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-Anvil"
+Issues = "https://github.com/Amulet-Team/Amulet-Anvil/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.anvil.__pyinstaller:get_hook_dirs"
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "src/amulet/anvil/_version.py"
+versionfile_build = "amulet/anvil/_version.py"
+tag_prefix = ""
+parentdir_prefix = "amulet-anvil-"

amulet_anvil-1.0.0a0/requirements.py

@@ -0,0 +1,120 @@
+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_ZLIB_REQUIREMENT = "~=1.0"
+AMULET_ZLIB_REQUIREMENT = "~=1.0.0.0a1"
+# AMULET_NBT_REQUIREMENT = "~=5.0"
+AMULET_NBT_REQUIREMENT = "~=5.0.0.0a1"
+# AMULET_CORE_REQUIREMENT = "~=2.0"
+AMULET_CORE_REQUIREMENT = "~=2.0.2.0a1"
+# AMULET_UTILS_REQUIREMENT = "~=1.1"
+AMULET_UTILS_REQUIREMENT = "~=1.1.0.0a2"
+
+
+if os.environ.get("AMULET_IO_REQUIREMENT", None):
+    AMULET_IO_REQUIREMENT = (
+        f"{AMULET_IO_REQUIREMENT},{os.environ['AMULET_IO_REQUIREMENT']}"
+    )
+
+if os.environ.get("AMULET_ZLIB_REQUIREMENT", None):
+    AMULET_ZLIB_REQUIREMENT = (
+        f"{AMULET_ZLIB_REQUIREMENT},{os.environ['AMULET_ZLIB_REQUIREMENT']}"
+    )
+
+if os.environ.get("AMULET_NBT_REQUIREMENT", None):
+    AMULET_NBT_REQUIREMENT = (
+        f"{AMULET_NBT_REQUIREMENT},{os.environ['AMULET_NBT_REQUIREMENT']}"
+    )
+
+if os.environ.get("AMULET_CORE_REQUIREMENT", None):
+    AMULET_CORE_REQUIREMENT = (
+        f"{AMULET_CORE_REQUIREMENT},{os.environ['AMULET_CORE_REQUIREMENT']}"
+    )
+
+if os.environ.get("AMULET_UTILS_REQUIREMENT", None):
+    AMULET_UTILS_REQUIREMENT = (
+        f"{AMULET_UTILS_REQUIREMENT},{os.environ['AMULET_UTILS_REQUIREMENT']}"
+    )
+
+
+def get_specifier_set(version_str: str) -> str:
+    """
+    version_str: The PEP 440 version number of the library.
+    """
+    version = Version(version_str)
+    if version.epoch != 0 or version.is_devrelease or version.is_postrelease:
+        raise RuntimeError(f"Unsupported version format. {version_str}")
+
+    return f"~={version.major}.{version.minor}.{version.micro}.0{''.join(map(str, version.pre or ()))}"
+
+
+if os.environ.get("AMULET_FREEZE_COMPILER", None):
+    AMULET_COMPILER_VERSION_REQUIREMENT = f"=={amulet_compiler_version.__version__}"
+
+    try:
+        import amulet.io
+    except ImportError:
+        pass
+    else:
+        AMULET_IO_REQUIREMENT = get_specifier_set(amulet.io.__version__)
+
+    try:
+        import amulet.zlib
+    except ImportError:
+        pass
+    else:
+        AMULET_ZLIB_REQUIREMENT = get_specifier_set(amulet.zlib.__version__)
+
+    try:
+        import amulet.nbt
+    except ImportError:
+        pass
+    else:
+        AMULET_NBT_REQUIREMENT = get_specifier_set(amulet.nbt.__version__)
+
+    try:
+        import amulet.core
+    except ImportError:
+        pass
+    else:
+        AMULET_CORE_REQUIREMENT = get_specifier_set(amulet.core.__version__)
+
+    try:
+        import amulet.utils
+    except ImportError:
+        pass
+    else:
+        AMULET_UTILS_REQUIREMENT = get_specifier_set(amulet.utils.__version__)
+
+
+def get_build_dependencies() -> list:
+    return [
+        f"pybind11{PYBIND11_REQUIREMENT}",
+        f"amulet_pybind11_extensions{AMULET_PYBIND11_EXTENSIONS_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+        f"amulet_io{AMULET_IO_REQUIREMENT}",
+        f"amulet-zlib{AMULET_ZLIB_REQUIREMENT}",
+        f"amulet-nbt{AMULET_NBT_REQUIREMENT}",
+        f"amulet-core{AMULET_CORE_REQUIREMENT}",
+        f"amulet-utils{AMULET_UTILS_REQUIREMENT}",
+    ]
+
+
+def get_runtime_dependencies() -> list[str]:
+    return [
+        f"pybind11{PYBIND11_REQUIREMENT}",
+        f"amulet-compiler-target{AMULET_COMPILER_TARGET_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+        f"amulet-zlib{AMULET_ZLIB_REQUIREMENT}",
+        f"amulet-nbt{AMULET_NBT_REQUIREMENT}",
+        f"amulet-core{AMULET_CORE_REQUIREMENT}",
+        f"amulet-utils{AMULET_UTILS_REQUIREMENT}",
+    ]

amulet_anvil-1.0.0a0/setup.cfg

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

amulet_anvil-1.0.0a0/setup.py

@@ -0,0 +1,128 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+import platform
+import datetime
+
+from setuptools import setup, Extension, Command
+from setuptools.command.build_ext import build_ext
+
+from packaging.version import Version
+
+import versioneer
+
+import requirements
+
+if (
+    os.environ.get("AMULET_FREEZE_COMPILER", None)
+    and sys.platform == "darwin"
+    and platform.machine() != "arm64"
+):
+    raise Exception("The MacOS frozen build must be created on arm64")
+
+
+def fix_path(path: str) -> str:
+    return os.path.realpath(path).replace(os.sep, "/")
+
+
+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
+        import amulet.core
+        import amulet.utils
+        import amulet.zlib
+
+        ext_dir = (
+            (Path.cwd() / self.get_ext_fullpath("")).parent.resolve()
+            / "amulet"
+            / "anvil"
+        )
+        anvil_src_dir = (
+            Path.cwd() / "src" / "amulet" / "anvil" 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"])
+        elif sys.platform == "darwin":
+            if platform.machine() == "arm64":
+                platform_args.append("-DCMAKE_OSX_ARCHITECTURES=x86_64;arm64")
+
+        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(amulet.core.__path__[0])}",
+                f"-Damulet_utils_DIR={fix_path(amulet.utils.__path__[0])}",
+                f"-Damulet_zlib_DIR={fix_path(amulet.zlib.__path__[0])}",
+                f"-Damulet_anvil_DIR={fix_path(anvil_src_dir)}",
+                f"-DAMULET_ANVIL_EXT_DIR={fix_path(ext_dir)}",
+                f"-DCMAKE_INSTALL_PREFIX=install",
+                "-B",
+                "build",
+            ]
+        ).returncode:
+            raise RuntimeError("Error configuring amulet_anvil")
+        if subprocess.run(
+            ["cmake", "--build", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_anvil")
+        if subprocess.run(
+            ["cmake", "--install", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_anvil")
+
+
+cmdclass["build_ext"] = CMakeBuild
+
+
+def _get_version() -> str:
+    version_str: str = versioneer.get_version()
+
+    if os.environ.get("AMULET_FREEZE_COMPILER", None):
+        date_format = "%y%m%d%H%M%S"
+        try:
+            with open("build/timestamp.txt", "r") as f:
+                timestamp = datetime.datetime.strptime(f.read(), date_format)
+        except Exception:
+            timestamp = datetime.datetime(1, 1, 1)
+        if datetime.timedelta(minutes=10) < datetime.datetime.now() - timestamp:
+            timestamp = datetime.datetime.now()
+            os.makedirs("build", exist_ok=True)
+            with open("build/timestamp.txt", "w") as f:
+                f.write(timestamp.strftime(date_format))
+
+        version = Version(version_str)
+        epoch = f"{version.epoch}!" if version.epoch else ""
+        release = ".".join(map(str, version.release))
+        pre = "".join(map(str, version.pre)) if version.is_prerelease else ""
+        post = f".post{timestamp.strftime(date_format)}"
+        local = f"+{version.local}" if version.local else ""
+        version_str = f"{epoch}{release}{pre}{post}{local}"
+
+    return version_str
+
+
+setup(
+    version=_get_version(),
+    cmdclass=cmdclass,
+    ext_modules=[Extension("amulet.anvil._amulet_anvil", [])],
+    install_requires=requirements.get_runtime_dependencies(),
+)

amulet_anvil-1.0.0a0/src/amulet/anvil/__init__.py

@@ -0,0 +1,39 @@
+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_anvil.dll")
+    elif sys.platform == "darwin":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_anvil.dylib")
+    elif sys.platform == "linux":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_anvil.so")
+    else:
+        raise RuntimeError(f"Unsupported platform {sys.platform}")
+
+    # Import dependencies
+    import amulet.nbt
+    import amulet.core
+    import amulet.utils
+    import amulet.zlib
+
+    # Load the shared library
+    ctypes.cdll.LoadLibrary(lib_path)
+
+    from ._amulet_anvil import init
+
+    init(sys.modules[__name__])
+
+
+_init()

amulet_anvil-1.0.0a0/src/amulet/anvil/__init__.pyi

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging as logging
+import typing
+
+import amulet.nbt
+from amulet.anvil.dimension import AnvilDimension, AnvilDimensionLayer
+from amulet.anvil.region import AnvilRegion, RegionDoesNotExist
+
+from . import _amulet_anvil, _version, dimension, region
+
+__all__ = [
+    "AnvilDimension",
+    "AnvilDimensionLayer",
+    "AnvilRegion",
+    "RawChunkType",
+    "RegionDoesNotExist",
+    "compiler_config",
+    "dimension",
+    "logging",
+    "region",
+]
+
+def _init() -> None: ...
+
+RawChunkType: typing.TypeAlias = dict[str, amulet.nbt.NamedTag]
+__version__: str
+compiler_config: dict

amulet_anvil-1.0.0a0/src/amulet/anvil/__pyinstaller/__init__.py

@@ -0,0 +1,2 @@
+def get_hook_dirs() -> list[str]:
+    return __path__

amulet_anvil-1.0.0a0/src/amulet/anvil/__pyinstaller/hook-amulet.anvil.py

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

amulet_anvil-1.0.0a0/src/amulet/anvil/_amulet_anvil.py.cpp

@@ -0,0 +1,36 @@
+#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;
+
+py::module init_anvil_region(py::module);
+py::module init_anvil_dimension(py::module);
+
+void init_module(py::module m)
+{
+    pyext::init_compiler_config(m);
+    pyext::check_compatibility(py::module::import("amulet.zlib"), m);
+    pyext::check_compatibility(py::module::import("amulet.nbt"), m);
+    pyext::check_compatibility(py::module::import("amulet.core"), m);
+    pyext::check_compatibility(py::module::import("amulet.utils"), m);
+
+    auto region = init_anvil_region(m);
+    auto dimension = init_anvil_dimension(m);
+
+    m.attr("AnvilRegion") = region.attr("AnvilRegion");
+    m.attr("RegionDoesNotExist") = region.attr("RegionDoesNotExist");
+    m.attr("AnvilDimensionLayer") = dimension.attr("AnvilDimensionLayer");
+    m.attr("AnvilDimension") = dimension.attr("AnvilDimension");
+    m.attr("RawChunkType") = dimension.attr("RawChunkType");
+}
+
+PYBIND11_MODULE(_amulet_anvil, 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_anvil-1.0.0a0/src/amulet/anvil/_amulet_anvil.pyi

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

amulet_anvil-1.0.0a0/src/amulet/anvil/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2025-06-12T11:19:40+0100",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "cfc71a65525a11eac462c9642380915a9622278b",
+ "version": "1.0.0a0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

amulet_anvil-1.0.0a0/src/amulet/anvil/amulet_anvilConfig.cmake

@@ -0,0 +1,23 @@
+if (NOT TARGET amulet_anvil)
+    message(STATUS "Finding amulet_anvil")
+
+    find_package(amulet_nbt CONFIG REQUIRED)
+    find_package(amulet_core CONFIG REQUIRED)
+    find_package(amulet_utils CONFIG REQUIRED)
+
+    set(amulet_anvil_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
+    find_library(amulet_anvil_LIBRARY NAMES amulet_anvil PATHS "${CMAKE_CURRENT_LIST_DIR}")
+    message(STATUS "amulet_anvil_LIBRARY: ${amulet_anvil_LIBRARY}")
+
+    add_library(amulet_anvil_bin SHARED IMPORTED)
+    set_target_properties(amulet_anvil_bin PROPERTIES
+        IMPORTED_IMPLIB "${amulet_anvil_LIBRARY}"
+    )
+
+    add_library(amulet_anvil INTERFACE)
+    target_link_libraries(amulet_anvil INTERFACE amulet_nbt)
+    target_link_libraries(amulet_anvil INTERFACE amulet_core)
+    target_link_libraries(amulet_anvil INTERFACE amulet_utils)
+    target_link_libraries(amulet_anvil INTERFACE amulet_anvil_bin)
+    target_include_directories(amulet_anvil INTERFACE ${amulet_anvil_INCLUDE_DIR})
+endif()