amulet-resource-pack 1.0.0a0__tar.gz

amulet_resource_pack-1.0.0a0/CMakeLists.txt

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(amulet_resource_pack 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()
+
+# Find libraries
+find_package(pybind11 CONFIG REQUIRED)
+find_package(amulet_pybind11_extensions CONFIG REQUIRED)
+find_package(amulet_io CONFIG REQUIRED)
+find_package(amulet_utils CONFIG REQUIRED)
+find_package(amulet_nbt CONFIG REQUIRED)
+find_package(amulet_core 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_resource_pack SHARED)
+target_compile_definitions(amulet_resource_pack PRIVATE ExportAmuletResourcePack)
+target_link_libraries(amulet_resource_pack PUBLIC pybind11::module)
+target_link_libraries(amulet_resource_pack PUBLIC amulet_pybind11_extensions)
+target_link_libraries(amulet_resource_pack PUBLIC amulet_io)
+target_link_libraries(amulet_resource_pack PUBLIC amulet_utils)
+target_link_libraries(amulet_resource_pack PUBLIC amulet_nbt)
+target_link_libraries(amulet_resource_pack PUBLIC amulet_core)
+target_include_directories(amulet_resource_pack PUBLIC ${SOURCE_PATH})
+target_sources(amulet_resource_pack 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_resource_pack)
+target_link_libraries(_amulet_resource_pack PRIVATE amulet_pybind11_extensions)
+target_link_libraries(_amulet_resource_pack PRIVATE amulet_resource_pack)
+target_compile_definitions(_amulet_resource_pack PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
+target_compile_definitions(_amulet_resource_pack PRIVATE PYBIND11_VERSION="${pybind11_VERSION}")
+target_compile_definitions(_amulet_resource_pack PRIVATE COMPILER_ID="${CMAKE_CXX_COMPILER_ID}")
+target_compile_definitions(_amulet_resource_pack PRIVATE COMPILER_VERSION="${CMAKE_CXX_COMPILER_VERSION}")
+target_sources(_amulet_resource_pack 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_RESOURCE_PACK_EXT_DIR)
+    set(AMULET_RESOURCE_PACK_EXT_DIR ${amulet_resource_pack_DIR})
+endif()
+
+# Install
+install(TARGETS amulet_resource_pack DESTINATION ${amulet_resource_pack_DIR})
+install(TARGETS _amulet_resource_pack DESTINATION ${AMULET_RESOURCE_PACK_EXT_DIR})
+
+if (DEFINED BUILD_AMULET_RESOURCE_PACK_TESTS)
+    add_subdirectory(tests)
+endif()

amulet_resource_pack-1.0.0a0/MANIFEST.in

@@ -0,0 +1,11 @@
+include build_requires.py
+include requirements.py
+
+include get_compiler/CMakeLists.txt
+include get_compiler/__init__.py
+
+recursive-include src/amulet *.cpp *.hpp *Config.cmake *.json *.mcmeta *.png
+
+include CMakeLists.txt
+
+prune tests

amulet_resource_pack-1.0.0a0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: amulet-resource-pack
+Version: 1.0.0a0
+Summary: A Python and C++ library for interacting with Minecraft resource packs.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-Resource-Pack
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-Resource-Pack/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==2.0
+Requires-Dist: amulet-compiler-version==3.0.0
+Requires-Dist: pybind11==2.13.6
+Requires-Dist: amulet-pybind11-extensions~=1.1.0.0a0
+Requires-Dist: amulet-io~=1.0
+Requires-Dist: amulet-utils~=1.1.0.0a5
+Requires-Dist: amulet-zlib~=1.0.0.0a6
+Requires-Dist: amulet-nbt~=5.0.0.0a6
+Requires-Dist: amulet-core~=2.0.3.0a1
+Requires-Dist: numpy~=2.0
+Requires-Dist: pillow~=11.0
+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 Resource Pack
+
+A Python and C++ library for interacting with Minecraft resource packs.

amulet_resource_pack-1.0.0a0/README.md

@@ -0,0 +1,3 @@
+# Amulet Resource Pack
+
+A Python and C++ library for interacting with Minecraft resource packs.

amulet_resource_pack-1.0.0a0/build_requires.py

@@ -0,0 +1,25 @@
+from typing import Union, Mapping
+
+from setuptools import build_meta
+from setuptools.build_meta import *
+
+import requirements
+
+
+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_resource_pack-1.0.0a0/get_compiler/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(get_compiler LANGUAGES CXX)
+
+# Set C++20
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+write_file("${CMAKE_BINARY_DIR}/compiler_id.txt" "${CMAKE_CXX_COMPILER_ID}")
+write_file("${CMAKE_BINARY_DIR}/compiler_version.txt" "${CMAKE_CXX_COMPILER_VERSION}")

amulet_resource_pack-1.0.0a0/get_compiler/__init__.py

@@ -0,0 +1,32 @@
+import os
+import subprocess
+
+Dir = os.path.dirname(__file__)
+
+
+def main() -> str:
+    if subprocess.run(["cmake", "--version"]).returncode:
+        raise RuntimeError("Could not find cmake")
+
+    # get the compiler id and version
+    if subprocess.run(
+        ["cmake", "-S", Dir, "-B", os.path.join(Dir, "build")]
+    ).returncode:
+        raise RuntimeError(
+            "Could not find a C++ 20 compiler. Do you have a C++ 20 compiler installed?"
+        )
+
+    # Get the compiler variables generated by the cmake file
+    with open(os.path.join(Dir, "build", "compiler_id.txt")) as f:
+        compiler_id_str = f.read().strip()
+    with open(os.path.join(Dir, "build", "compiler_version.txt")) as f:
+        compiler_version = f.read().strip()
+
+    # convert the compiler id to an int so it can be used in a version number
+    compiler_id_int = 0
+    for b in compiler_id_str.encode("utf-8"):
+        compiler_id_int <<= 8
+        compiler_id_int += b
+
+    # combine the compiler id and compiler version into a version number
+    return f"==3.0.0.{compiler_id_int}.{compiler_version}"

amulet_resource_pack-1.0.0a0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "versioneer",
+    "packaging",
+]
+build-backend = "build_requires"
+backend-path = [""]
+
+[project]
+name = "amulet-resource-pack"
+authors = [
+    {name = "James Clare"},
+]
+description = "A Python and C++ library for interacting with Minecraft resource packs."
+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-Resource-Pack"
+Issues = "https://github.com/Amulet-Team/Amulet-Resource-Pack/issues"
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.package-data]
+"*" = [
+    "*Config.cmake",
+    "**/*.hpp",
+    "**/*.dll",
+    "**/*.so",
+    "**/*.dylib",
+    "**/*.lib",
+    "**/*.json",
+    "**/*.mcmeta",
+    "**/*.png",
+]
+
+[tool.setuptools.dynamic]
+readme = {file = ["README.md"], content-type = "text/markdown"}
+
+[project.entry-points.pyinstaller40]
+hook-dirs = "amulet.resource_pack.__pyinstaller:get_hook_dirs"
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "src/amulet/resource_pack/_version.py"
+versionfile_build = "amulet/resource_pack/_version.py"
+tag_prefix = ""
+parentdir_prefix = "amulet_resource_pack-"

amulet_resource_pack-1.0.0a0/requirements.py

@@ -0,0 +1,133 @@
+import os
+from packaging.version import Version
+
+AMULET_COMPILER_TARGET_REQUIREMENT = "==2.0"
+AMULET_COMPILER_VERSION_REQUIREMENT = "==3.0.0"
+
+PYBIND11_REQUIREMENT = "==2.13.6"
+AMULET_PYBIND11_EXTENSIONS_REQUIREMENT = "~=1.1.0.0a0"
+AMULET_IO_REQUIREMENT = "~=1.0"
+AMULET_UTILS_REQUIREMENT = "~=1.1.0.0a5"
+AMULET_ZLIB_REQUIREMENT = "~=1.0.0.0a6"
+AMULET_NBT_REQUIREMENT = "~=5.0.0.0a6"
+AMULET_CORE_REQUIREMENT = "~=2.0.3.0a1"
+NUMPY_REQUIREMENT = "~=2.0"
+PIL_REQUIREMENT = "~=11.0"
+
+if os.environ.get("AMULET_PYBIND11_EXTENSIONS_REQUIREMENT", None):
+    AMULET_PYBIND11_EXTENSIONS_REQUIREMENT = f"{AMULET_PYBIND11_EXTENSIONS_REQUIREMENT},{os.environ['AMULET_PYBIND11_EXTENSIONS_REQUIREMENT']}"
+
+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_UTILS_REQUIREMENT", None):
+    AMULET_UTILS_REQUIREMENT = (
+        f"{AMULET_UTILS_REQUIREMENT},{os.environ['AMULET_UTILS_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']}"
+    )
+
+
+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):
+    import get_compiler
+
+    AMULET_COMPILER_VERSION_REQUIREMENT = get_compiler.main()
+
+    try:
+        import amulet.pybind11_extensions
+    except ImportError:
+        pass
+    else:
+        AMULET_PYBIND11_EXTENSIONS_REQUIREMENT = get_specifier_set(
+            amulet.pybind11_extensions.__version__
+        )
+
+    try:
+        import amulet.io
+    except ImportError:
+        pass
+    else:
+        AMULET_IO_REQUIREMENT = get_specifier_set(amulet.io.__version__)
+
+    try:
+        import amulet.utils
+    except ImportError:
+        pass
+    else:
+        AMULET_UTILS_REQUIREMENT = get_specifier_set(amulet.utils.__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__)
+
+
+def get_build_dependencies() -> list:
+    return [
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+        f"pybind11{PYBIND11_REQUIREMENT}",
+        f"amulet-pybind11-extensions{AMULET_PYBIND11_EXTENSIONS_REQUIREMENT}",
+        f"amulet-io{AMULET_IO_REQUIREMENT}",
+        f"amulet-utils{AMULET_UTILS_REQUIREMENT}",
+        f"amulet-zlib{AMULET_ZLIB_REQUIREMENT}",
+        f"amulet-nbt{AMULET_NBT_REQUIREMENT}",
+        f"amulet-core{AMULET_CORE_REQUIREMENT}",
+    ] * (not os.environ.get("AMULET_SKIP_COMPILE", None))
+
+
+def get_runtime_dependencies() -> list[str]:
+    return [
+        f"amulet-compiler-target{AMULET_COMPILER_TARGET_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+        f"pybind11{PYBIND11_REQUIREMENT}",
+        f"amulet-pybind11-extensions{AMULET_PYBIND11_EXTENSIONS_REQUIREMENT}",
+        f"amulet-io{AMULET_IO_REQUIREMENT}",
+        f"amulet-utils{AMULET_UTILS_REQUIREMENT}",
+        f"amulet-zlib{AMULET_ZLIB_REQUIREMENT}",
+        f"amulet-nbt{AMULET_NBT_REQUIREMENT}",
+        f"amulet-core{AMULET_CORE_REQUIREMENT}",
+        f"numpy{NUMPY_REQUIREMENT}",
+        f"pillow{PIL_REQUIREMENT}",
+    ]

amulet_resource_pack-1.0.0a0/setup.cfg

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

amulet_resource_pack-1.0.0a0/setup.py

@@ -0,0 +1,133 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+import platform
+import datetime
+from tempfile import TemporaryDirectory
+
+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.utils
+        import amulet.nbt
+        import amulet.core
+
+        ext_dir = (
+            (Path.cwd() / self.get_ext_fullpath("")).parent.resolve()
+            / "amulet"
+            / "resource_pack"
+        )
+        resource_pack_src_dir = (
+            Path.cwd() / "src" / "amulet" / "resource_pack"
+            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", "--version"]).returncode:
+            raise RuntimeError("Could not find cmake")
+        with TemporaryDirectory() as tempdir:
+            if subprocess.run(
+                [
+                    "cmake",
+                    *platform_args,
+                    f"-DPYTHON_EXECUTABLE={sys.executable}",
+                    f"-Dpybind11_DIR={fix_path(pybind11.get_cmake_dir())}",
+                    f"-Damulet_pybind11_extensions_DIR={fix_path(amulet.pybind11_extensions.__path__[0])}",
+                    f"-Damulet_io_DIR={fix_path(amulet.io.__path__[0])}",
+                    f"-Damulet_utils_DIR={fix_path(amulet.utils.__path__[0])}",
+                    f"-Damulet_nbt_DIR={fix_path(amulet.nbt.__path__[0])}",
+                    f"-Damulet_core_DIR={fix_path(amulet.core.__path__[0])}",
+                    f"-Damulet_resource_pack_DIR={fix_path(resource_pack_src_dir)}",
+                    f"-DAMULET_RESOURCE_PACK_EXT_DIR={fix_path(ext_dir)}",
+                    f"-DCMAKE_INSTALL_PREFIX=install",
+                    "-B",
+                    tempdir,
+                ]
+            ).returncode:
+                raise RuntimeError("Error configuring amulet-resource-pack")
+            if subprocess.run(
+                ["cmake", "--build", tempdir, "--config", "Release"]
+            ).returncode:
+                raise RuntimeError("Error building amulet-resource-pack")
+            if subprocess.run(
+                ["cmake", "--install", tempdir, "--config", "Release"]
+            ).returncode:
+                raise RuntimeError("Error installing amulet-resource-pack")
+
+
+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.resource_pack._amulet_resource_pack", [])]
+    * (not os.environ.get("AMULET_SKIP_COMPILE", None)),
+    install_requires=requirements.get_runtime_dependencies(),
+)

amulet_resource_pack-1.0.0a0/src/amulet/resource_pack/__init__.py

@@ -0,0 +1,60 @@
+import logging as _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_resource_pack.dll")
+    elif sys.platform == "darwin":
+        lib_path = os.path.join(
+            os.path.dirname(__file__), "libamulet_resource_pack.dylib"
+        )
+    elif sys.platform == "linux":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_resource_pack.so")
+    else:
+        raise RuntimeError(f"Unsupported platform {sys.platform}")
+
+    # Import dependencies
+    import amulet.utils
+    import amulet.zlib
+    import amulet.nbt
+    import amulet.core
+
+    # Load the shared library
+    ctypes.cdll.LoadLibrary(lib_path)
+
+    from ._amulet_resource_pack import init
+
+    init(sys.modules[__name__])
+
+
+_init()
+
+from amulet.resource_pack.abc import (
+    BaseResourcePack,
+    BaseResourcePackManager,
+)
+
+from .unknown_resource_pack import UnknownResourcePack
+
+from amulet.resource_pack.java import (
+    JavaResourcePack,
+    JavaResourcePackManager,
+)
+
+# from amulet.resource_pack.bedrock import (
+#     BedrockResourcePack,
+#     BedrockResourcePackManager,
+# )
+
+from ._load import load_resource_pack, load_resource_pack_manager

amulet_resource_pack-1.0.0a0/src/amulet/resource_pack/__init__.pyi

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import logging as logging
+
+from amulet.resource_pack._load import load_resource_pack, load_resource_pack_manager
+from amulet.resource_pack.abc.resource_pack import BaseResourcePack
+from amulet.resource_pack.abc.resource_pack_manager import BaseResourcePackManager
+from amulet.resource_pack.java.resource_pack import JavaResourcePack
+from amulet.resource_pack.java.resource_pack_manager import JavaResourcePackManager
+from amulet.resource_pack.unknown_resource_pack import UnknownResourcePack
+
+from . import (
+    _amulet_resource_pack,
+    _load,
+    _version,
+    abc,
+    image,
+    java,
+    mesh,
+    unknown_resource_pack,
+)
+
+__all__ = [
+    "BaseResourcePack",
+    "BaseResourcePackManager",
+    "JavaResourcePack",
+    "JavaResourcePackManager",
+    "UnknownResourcePack",
+    "abc",
+    "compiler_config",
+    "image",
+    "java",
+    "load_resource_pack",
+    "load_resource_pack_manager",
+    "logging",
+    "mesh",
+    "unknown_resource_pack",
+]
+
+def _init() -> None: ...
+
+__version__: str
+compiler_config: dict = {
+    "pybind11_version": "2.13.6",
+    "compiler_id": "MSVC",
+    "compiler_version": "19.43.34808.0",
+}

amulet_resource_pack-1.0.0a0/src/amulet/resource_pack/__pyinstaller/__init__.py

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

amulet_resource_pack-1.0.0a0/src/amulet/resource_pack/__pyinstaller/hook-amulet.resource_pack.py

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