amulet-zlib 1.0.0a0__tar.gz

amulet_zlib-1.0.0a0/CMakeLists.txt

@@ -0,0 +1,92 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(amulet_zlib 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 pybind11
+find_package(pybind11 CONFIG REQUIRED)
+find_package(amulet_pybind11_extensions CONFIG REQUIRED)
+
+# Find C++ files
+file(REAL_PATH src SOURCE_PATH)
+file(GLOB_RECURSE SOURCES LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.cpp)
+file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false ${SOURCE_PATH}/amulet/*.hpp)
+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)
+list(REMOVE_ITEM SOURCES ${EXTENSION_SOURCES})
+list(REMOVE_ITEM HEADERS ${EXTENSION_HEADERS})
+
+# Add implementation
+add_library(amulet_zlib SHARED)
+target_link_libraries( amulet_zlib PRIVATE zlibstatic )
+target_compile_definitions(amulet_zlib PRIVATE ExportAmuletZlib)
+target_include_directories(amulet_zlib PUBLIC "src")
+target_sources(amulet_zlib 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_zlib)
+target_compile_definitions(_amulet_zlib PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
+target_compile_definitions(_amulet_zlib PRIVATE PYBIND11_VERSION="${pybind11_VERSION}")
+target_compile_definitions(_amulet_zlib PRIVATE COMPILER_ID="${CMAKE_CXX_COMPILER_ID}")
+target_compile_definitions(_amulet_zlib PRIVATE COMPILER_VERSION="${CMAKE_CXX_COMPILER_VERSION}")
+target_link_libraries(_amulet_zlib PRIVATE amulet_pybind11_extensions)
+target_link_libraries(_amulet_zlib PRIVATE amulet_zlib)
+target_sources(_amulet_zlib 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_ZLIB_EXT_DIR)
+    set(AMULET_ZLIB_EXT_DIR ${amulet_zlib_DIR})
+endif()
+
+# Install
+install(TARGETS amulet_zlib DESTINATION ${amulet_zlib_DIR})
+install(TARGETS _amulet_zlib DESTINATION ${AMULET_ZLIB_EXT_DIR})
+
+if (TEST_AMULET_ZLIB_DIR)
+    add_subdirectory(tests)
+endif()

amulet_zlib-1.0.0a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gentlegiantJGC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amulet_zlib-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_zlib-1.0.0a0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: amulet-zlib
+Version: 1.0.0a0
+Summary: A Python and C++ wrapper around zlib.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-zlib
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-zlib/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: amulet-compiler-target==1.0
+Requires-Dist: amulet-compiler-version==3.0.0
+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==2.13.6; extra == "dev"
+Requires-Dist: amulet_pybind11_extensions~=1.0; extra == "dev"
+Requires-Dist: black>=22.3; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-pyinstaller; extra == "dev"
+Requires-Dist: amulet-test-utils~=1.1; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Amulet-zlib
+
+A Python and C++ wrapper around zlib.

amulet_zlib-1.0.0a0/README.md

@@ -0,0 +1,3 @@
+# Amulet-zlib
+
+A Python and C++ wrapper around zlib.

amulet_zlib-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_zlib-1.0.0a0/pyproject.toml

@@ -0,0 +1,73 @@
+[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-zlib"
+authors = [
+    {name = "James Clare"},
+]
+description = "A Python and C++ wrapper around zlib."
+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==2.13.6",
+    "amulet_pybind11_extensions~=1.0",
+    "black>=22.3",
+    "mypy",
+    "types-pyinstaller",
+    "amulet-test-utils~=1.1",
+]
+
+[project.urls]
+Homepage = "https://www.amuletmc.com"
+Repository = "https://github.com/Amulet-Team/Amulet-zlib"
+Issues = "https://github.com/Amulet-Team/Amulet-zlib/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.zlib.__pyinstaller:get_hook_dirs"
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "src/amulet/zlib/_version.py"
+versionfile_build = "amulet/zlib/_version.py"
+tag_prefix = ""
+parentdir_prefix = "amulet_zlib-"

amulet_zlib-1.0.0a0/requirements.py

@@ -0,0 +1,28 @@
+import os
+from packaging.version import Version
+
+import amulet_compiler_version
+
+PYBIND11_REQUIREMENT = "==2.13.6"
+AMULET_COMPILER_TARGET_REQUIREMENT = "==1.0"
+AMULET_COMPILER_VERSION_REQUIREMENT = "==3.0.0"
+AMULET_PYBIND11_EXTENSIONS_REQUIREMENT = "~=1.0"
+
+
+if os.environ.get("AMULET_FREEZE_COMPILER", None):
+    AMULET_COMPILER_VERSION_REQUIREMENT = f"=={amulet_compiler_version.__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}",
+    ]
+
+
+def get_runtime_dependencies() -> list[str]:
+    return [
+        f"amulet-compiler-target{AMULET_COMPILER_TARGET_REQUIREMENT}",
+        f"amulet-compiler-version{AMULET_COMPILER_VERSION_REQUIREMENT}",
+    ]

amulet_zlib-1.0.0a0/setup.cfg

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

amulet_zlib-1.0.0a0/setup.py

@@ -0,0 +1,122 @@
+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, "/")
+
+
+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
+
+        ext_dir = (
+            (Path.cwd() / self.get_ext_fullpath("")).parent.resolve()
+            / "amulet"
+            / "zlib"
+        )
+        zlib_src_dir = (
+            Path.cwd() / "src" / "amulet" / "zlib" 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={fix_path(pybind11.get_cmake_dir())}",
+                f"-Damulet_pybind11_extensions_DIR={(amulet.pybind11_extensions.__path__[0])}",
+                f"-Damulet_zlib_DIR={fix_path(zlib_src_dir)}",
+                f"-DAMULET_ZLIB_EXT_DIR={fix_path(ext_dir)}",
+                f"-DCMAKE_INSTALL_PREFIX=install",
+                "-B",
+                "build",
+            ]
+        ).returncode:
+            raise RuntimeError("Error configuring amulet_zlib")
+        if subprocess.run(
+            ["cmake", "--build", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_zlib")
+        if subprocess.run(
+            ["cmake", "--install", "build", "--config", "Release"]
+        ).returncode:
+            raise RuntimeError("Error installing amulet_zlib")
+
+
+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)
+            print("using cached timestamp")
+        except Exception:
+            timestamp = datetime.datetime(1, 1, 1)
+        if datetime.timedelta(minutes=10) < datetime.datetime.now() - timestamp:
+            print("get 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.zlib._amulet_zlib", [])],
+    install_requires=dependencies,
+)

amulet_zlib-1.0.0a0/src/amulet/zlib/__init__.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from amulet.zlib import _version
+
+__version__ = _version.get_versions()["version"]
+
+if TYPE_CHECKING:
+
+    class ZipBombException(RuntimeError):
+        pass
+
+    def get_max_decompression_size() -> int: ...
+    def set_max_decompression_size(max_decompression_size: int) -> None: ...
+
+    def decompress_zlib_gzip(src: bytes) -> bytes: ...
+    def compress_zlib(src: bytes) -> bytes: ...
+    def compress_gzip(src: bytes) -> bytes: ...
+
+
+def _init() -> None:
+    import os
+    import sys
+    import ctypes
+
+    if sys.platform == "win32":
+        lib_path = os.path.join(os.path.dirname(__file__), "amulet_zlib.dll")
+    elif sys.platform == "darwin":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_zlib.dylib")
+    elif sys.platform == "linux":
+        lib_path = os.path.join(os.path.dirname(__file__), "libamulet_zlib.so")
+    else:
+        raise RuntimeError(f"Unsupported platform {sys.platform}")
+
+    # Load the shared library
+    ctypes.cdll.LoadLibrary(lib_path)
+
+    from ._amulet_zlib import init
+
+    init(sys.modules[__name__])
+
+
+_init()

amulet_zlib-1.0.0a0/src/amulet/zlib/__pyinstaller/__init__.py

@@ -0,0 +1,2 @@
+def get_hook_dirs():
+    return __path__

amulet_zlib-1.0.0a0/src/amulet/zlib/__pyinstaller/hook-amulet_zlib.py

@@ -0,0 +1,3 @@
+from PyInstaller.utils.hooks import collect_submodules
+
+hiddenimports = collect_submodules("amulet.zlib")

amulet_zlib-1.0.0a0/src/amulet/zlib/_amulet_zlib.py.cpp

@@ -0,0 +1,66 @@
+#include <pybind11/pybind11.h>
+
+#include <amulet/pybind11_extensions/compatibility.hpp>
+
+#include <amulet/zlib/zlib.hpp>
+
+namespace py = pybind11;
+namespace pyext = Amulet::pybind11_extensions;
+
+void init_module(py::module& m)
+{
+    pyext::init_compiler_config(m);
+
+    py::register_exception<Amulet::zlib::ZipBombException>(m, "ZipBombException");
+
+    m.def(
+        "get_max_decompression_size",
+        &Amulet::zlib::get_max_decompression_size,
+        py::doc("Get the configured maximum decompressed size in bytes. (Default 100MB)"));
+    m.def(
+        "set_max_decompression_size",
+        &Amulet::zlib::set_max_decompression_size,
+        py::doc(
+            "Set the configured maximum decompressed size in bytes.\n"
+            "If decompression requires more memory than this it will raise ZipBombException."));
+
+    m.def(
+        "decompress_zlib_gzip",
+        [](py::bytes src) {
+            std::string dst;
+            {
+                py::gil_scoped_release nogil;
+                Amulet::zlib::decompress_zlib_gzip(src, dst);
+            }
+            return py::bytes(dst);
+        },
+        py::doc(
+            "Decompress a bytes object compressed with either zlib or gzip.\n"
+            "Raises ZipBombException if decompression requires more than the configured maximum decompression size."));
+    m.def(
+        "compress_zlib",
+        [](py::bytes src) {
+            std::string dst;
+            {
+                py::gil_scoped_release nogil;
+                Amulet::zlib::compress_zlib(src, dst);
+            }
+            return py::bytes(dst);
+        },
+        py::doc("Compress a bytes object using the zlib compression format."));
+    m.def(
+        "compress_gzip",
+        [](py::bytes src) {
+        std::string dst;
+        {
+            py::gil_scoped_release nogil;
+            Amulet::zlib::compress_gzip(src, dst);
+        }
+        return py::bytes(dst); },
+        py::doc("Compress a bytes object using the gzip compression format."));
+}
+
+PYBIND11_MODULE(_amulet_zlib, m)
+{
+    m.def("init", &init_module);
+}

amulet_zlib-1.0.0a0/src/amulet/zlib/_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-05-30T13:52:49+0100",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "1e657bcaad7fd55c431ae3fb311b4ebd90026ab4",
+ "version": "1.0.0a0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

amulet_zlib-1.0.0a0/src/amulet/zlib/amulet_zlibConfig.cmake

@@ -0,0 +1,13 @@
+if (NOT TARGET amulet_zlib)
+    message(STATUS "Finding amulet_zlib")
+
+    set(amulet_zlib_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/../..")
+    find_library(amulet_zlib_LIBRARY NAMES amulet_zlib PATHS "${CMAKE_CURRENT_LIST_DIR}")
+    message(STATUS "amulet_zlib_LIBRARY: ${amulet_zlib_LIBRARY}")
+
+    add_library(amulet_zlib SHARED IMPORTED)
+    set_target_properties(amulet_zlib PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${amulet_zlib_INCLUDE_DIR}"
+        IMPORTED_IMPLIB "${amulet_zlib_LIBRARY}"
+    )
+endif()

amulet_zlib-1.0.0a0/src/amulet/zlib/export.hpp

@@ -0,0 +1,19 @@
+#ifndef AMULET_ZLIB_EXPORT
+    #ifdef _WIN32
+        #ifdef ExportAmuletZlib
+            #define AMULET_ZLIB_EXPORT __declspec(dllexport)
+        #else
+            #define AMULET_ZLIB_EXPORT __declspec(dllimport)
+        #endif
+    #else
+        #define AMULET_ZLIB_EXPORT
+    #endif
+#endif
+
+#if !defined(AMULET_ZLIB_EXPORT_EXCEPTION)
+    #if defined(_LIBCPP_EXCEPTION)
+        #define AMULET_ZLIB_EXPORT_EXCEPTION __attribute__((visibility("default")))
+    #else
+        #define AMULET_ZLIB_EXPORT_EXCEPTION
+    #endif
+#endif

amulet_zlib-1.0.0a0/src/amulet/zlib/zlib.cpp

@@ -0,0 +1,190 @@
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+#include <zlib.h>
+
+#include <amulet/zlib/zlib.hpp>
+
+#define MAX_AVAIL_IN std::numeric_limits<uInt>::max()
+#define DST_CHUNK_SIZE 65536
+static_assert(MAX_AVAIL_IN <= std::numeric_limits<uInt>::max());
+static_assert(DST_CHUNK_SIZE <= std::numeric_limits<uInt>::max());
+
+namespace Amulet {
+namespace zlib {
+
+    static size_t _max_decompression_size = 100000000; // 100MB
+
+    size_t get_max_decompression_size()
+    {
+        return _max_decompression_size;
+    }
+
+    void set_max_decompression_size(size_t max_decompression_size)
+    {
+        _max_decompression_size = max_decompression_size;
+    }
+
+    void decompress_zlib_gzip(const std::string_view src, std::string& dst)
+    {
+        // Initialise the stream
+        z_stream stream = { 0 };
+        switch (inflateInit2(&stream, 32 + MAX_WBITS)) {
+        case Z_MEM_ERROR:
+            throw std::bad_alloc();
+        case Z_VERSION_ERROR:
+            throw std::runtime_error("Incompatible zlib library.");
+        case Z_STREAM_ERROR:
+            throw std::runtime_error("zlib stream is invalid.");
+        }
+
+        size_t src_index = 0;
+        size_t dst_start_size = dst.size();
+        size_t dst_index = dst.size();
+        int err;
+
+        do {
+            stream.avail_in = static_cast<uInt>(std::min<size_t>(src.size() - src_index, MAX_AVAIL_IN));
+            if (stream.avail_in == 0) {
+                break;
+            }
+            stream.next_in = reinterpret_cast<z_const Bytef*>(&src[src_index]);
+            src_index += stream.avail_in;
+
+            do {
+                // zip bomb check
+                if (_max_decompression_size < dst_index - dst_start_size) {
+                    throw ZipBombException("Decompression requires more memory than the configured maximum.");
+                }
+                // allocate data after dst
+                dst.resize(dst_index + DST_CHUNK_SIZE);
+                // Assign the location to decompress into
+                stream.next_out = reinterpret_cast<Bytef*>(&dst[dst_index]);
+                stream.avail_out = DST_CHUNK_SIZE;
+
+                // Decompress
+                err = inflate(&stream, Z_NO_FLUSH);
+
+                switch (err) {
+                case Z_NEED_DICT:
+                case Z_DATA_ERROR:
+                    inflateEnd(&stream);
+                    throw std::invalid_argument("Cannot decompress corrupt zlib data.");
+                case Z_MEM_ERROR:
+                    inflateEnd(&stream);
+                    throw std::bad_alloc();
+                case Z_STREAM_ERROR:
+                    inflateEnd(&stream);
+                    throw std::runtime_error("zlib stream is invalid.");
+                }
+                // increment dst_index
+                dst_index += DST_CHUNK_SIZE - stream.avail_out;
+            } while (stream.avail_out == 0);
+        } while (err != Z_STREAM_END);
+
+        // Remove unused bytes
+        dst.resize(dst_index);
+        // Clear stream data
+        inflateEnd(&stream);
+    }
+
+    void compress_zlib(const std::string_view src, std::string& dst)
+    {
+        // Initialise the stream
+        z_stream stream = { 0 };
+        switch (deflateInit2(&stream, Z_BEST_COMPRESSION, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY)) {
+        case Z_MEM_ERROR:
+            throw std::bad_alloc();
+        case Z_VERSION_ERROR:
+            throw std::runtime_error("Incompatible zlib library.");
+        case Z_STREAM_ERROR:
+            throw std::runtime_error("zlib stream is invalid.");
+        }
+
+        size_t src_index = 0;
+        size_t dst_index = dst.size();
+        int err;
+        int flush;
+
+        do {
+            stream.avail_in = static_cast<uInt>(std::min<size_t>(src.size() - src_index, MAX_AVAIL_IN));
+            stream.next_in = reinterpret_cast<z_const Bytef*>(&src[src_index]);
+            src_index += stream.avail_in;
+            flush = (src.size() == src_index) ? Z_FINISH : Z_NO_FLUSH;
+
+            do {
+                // allocate data after dst
+                dst.resize(dst_index + DST_CHUNK_SIZE);
+                // Assign the location to decompress into
+                stream.next_out = reinterpret_cast<Bytef*>(&dst[dst_index]);
+                stream.avail_out = DST_CHUNK_SIZE;
+
+                // Compress
+                err = deflate(&stream, flush);
+                if (err == Z_STREAM_ERROR) {
+                    deflateEnd(&stream);
+                    throw std::runtime_error("zlib stream is invalid.");
+                }
+                // increment dst_index
+                dst_index += DST_CHUNK_SIZE - stream.avail_out;
+            } while (stream.avail_out == 0);
+        } while (src_index < src.size());
+
+        // Remove unused bytes
+        dst.resize(dst_index);
+        // Clear stream data
+        deflateEnd(&stream);
+    }
+
+    void compress_gzip(const std::string_view src, std::string& dst)
+    {
+        // Initialise the stream
+        z_stream stream = { 0 };
+        switch (deflateInit2(&stream, Z_BEST_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY)) {
+        case Z_MEM_ERROR:
+            throw std::bad_alloc();
+        case Z_VERSION_ERROR:
+            throw std::runtime_error("Incompatible zlib library.");
+        case Z_STREAM_ERROR:
+            throw std::runtime_error("zlib stream is invalid.");
+        }
+
+        size_t src_index = 0;
+        size_t dst_index = dst.size();
+        int err;
+        int flush;
+
+        do {
+            stream.avail_in = static_cast<uInt>(std::min<size_t>(src.size() - src_index, MAX_AVAIL_IN));
+            stream.next_in = reinterpret_cast<z_const Bytef*>(&src[src_index]);
+            src_index += stream.avail_in;
+            flush = (src.size() == src_index) ? Z_FINISH : Z_NO_FLUSH;
+
+            do {
+                // allocate data after dst
+                dst.resize(dst_index + DST_CHUNK_SIZE);
+                // Assign the location to decompress into
+                stream.next_out = reinterpret_cast<Bytef*>(&dst[dst_index]);
+                stream.avail_out = DST_CHUNK_SIZE;
+
+                // Compress
+                err = deflate(&stream, flush);
+                if (err == Z_STREAM_ERROR) {
+                    deflateEnd(&stream);
+                    throw std::runtime_error("zlib stream is invalid.");
+                }
+                // increment dst_index
+                dst_index += DST_CHUNK_SIZE - stream.avail_out;
+            } while (stream.avail_out == 0);
+        } while (src_index < src.size());
+
+        // Remove unused bytes
+        dst.resize(dst_index);
+        // Clear stream data
+        deflateEnd(&stream);
+    }
+
+} // namespace zlib
+} // namespace Amulet

amulet_zlib-1.0.0a0/src/amulet/zlib/zlib.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+#include <amulet/zlib/export.hpp>
+
+namespace Amulet {
+namespace zlib {
+
+    class AMULET_ZLIB_EXPORT_EXCEPTION ZipBombException : public std::runtime_error {
+    public:
+        using std::runtime_error::runtime_error;
+    };
+
+    // Get the configured maximum decompressed size in bytes. (Default 100MB)
+    AMULET_ZLIB_EXPORT size_t get_max_decompression_size();
+
+    // Set the configured maximum decompressed size in bytes.
+    // If decompression requires more memory than this it will raise ZipBombException.
+    AMULET_ZLIB_EXPORT void set_max_decompression_size(size_t);
+
+    // Decompress zlib or gzip compressed data from src into dst.
+    // Throws ZipBombException if decompression requires more than the configured maximum decompression size.
+    AMULET_ZLIB_EXPORT void decompress_zlib_gzip(const std::string_view src, std::string& dst);
+
+    // Compress the data in src in zlib format and append to dst.
+    AMULET_ZLIB_EXPORT void compress_zlib(const std::string_view src, std::string& dst);
+
+    // Compress the data in src in gzip format and append to dst.
+    AMULET_ZLIB_EXPORT void compress_gzip(const std::string_view src, std::string& dst);
+
+} // namespace zlib
+} // namespace Amulet

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: amulet-zlib
+Version: 1.0.0a0
+Summary: A Python and C++ wrapper around zlib.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-zlib
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-zlib/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: amulet-compiler-target==1.0
+Requires-Dist: amulet-compiler-version==3.0.0
+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==2.13.6; extra == "dev"
+Requires-Dist: amulet_pybind11_extensions~=1.0; extra == "dev"
+Requires-Dist: black>=22.3; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-pyinstaller; extra == "dev"
+Requires-Dist: amulet-test-utils~=1.1; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Amulet-zlib
+
+A Python and C++ wrapper around zlib.

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+CMakeLists.txt
+LICENSE
+MANIFEST.in
+README.md
+build_requires.py
+pyproject.toml
+requirements.py
+setup.py
+src/amulet/zlib/__init__.py
+src/amulet/zlib/_amulet_zlib.py.cpp
+src/amulet/zlib/_version.py
+src/amulet/zlib/amulet_zlibConfig.cmake
+src/amulet/zlib/export.hpp
+src/amulet/zlib/py.typed
+src/amulet/zlib/zlib.cpp
+src/amulet/zlib/zlib.hpp
+src/amulet/zlib/__pyinstaller/__init__.py
+src/amulet/zlib/__pyinstaller/hook-amulet_zlib.py
+src/amulet_zlib.egg-info/PKG-INFO
+src/amulet_zlib.egg-info/SOURCES.txt
+src/amulet_zlib.egg-info/dependency_links.txt
+src/amulet_zlib.egg-info/entry_points.txt
+src/amulet_zlib.egg-info/requires.txt
+src/amulet_zlib.egg-info/top_level.txt

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/entry_points.txt

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

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/requires.txt

@@ -0,0 +1,19 @@
+amulet-compiler-target==1.0
+amulet-compiler-version==3.0.0
+
+[dev]
+setuptools>=42
+versioneer
+packaging
+wheel
+pybind11==2.13.6
+amulet_pybind11_extensions~=1.0
+black>=22.3
+mypy
+types-pyinstaller
+amulet-test-utils~=1.1
+
+[docs]
+Sphinx>=1.7.4
+sphinx-autodoc-typehints>=1.3.0
+sphinx_rtd_theme>=0.3.1

amulet_zlib-1.0.0a0/src/amulet_zlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+amulet