hatch-cpp 0.1.6__py3-none-any.whl

hatch_cpp/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.6"
+
+from .hooks import hatch_register_build_hook
+from .plugin import HatchCppBuildHook
+from .structs import *

hatch_cpp/hooks.py

@@ -0,0 +1,10 @@
+from typing import Type
+
+from hatchling.plugin import hookimpl
+
+from .plugin import HatchCppBuildHook
+
+
+@hookimpl
+def hatch_register_build_hook() -> Type[HatchCppBuildHook]:
+    return HatchCppBuildHook

hatch_cpp/plugin.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import logging
+import os
+import platform as sysplatform
+import sys
+import typing as t
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+from .structs import HatchCppBuildConfig, HatchCppBuildPlan
+from .utils import import_string
+
+__all__ = ("HatchCppBuildHook",)
+
+
+class HatchCppBuildHook(BuildHookInterface[HatchCppBuildConfig]):
+    """The hatch-cpp build hook."""
+
+    PLUGIN_NAME = "hatch-cpp"
+    _logger = logging.getLogger(__name__)
+
+    def initialize(self, version: str, build_data: dict[str, t.Any]) -> None:
+        """Initialize the plugin."""
+        # Log some basic information
+        self._logger.info("Initializing hatch-cpp plugin version %s", version)
+        self._logger.info("Running hatch-cpp")
+
+        # Only run if creating wheel
+        # TODO: Add support for specify sdist-plan
+        if self.target_name != "wheel":
+            self._logger.info("ignoring target name %s", self.target_name)
+            return
+
+        # Skip if SKIP_HATCH_CPP is set
+        # TODO: Support CLI once https://github.com/pypa/hatch/pull/1743
+        if os.getenv("SKIP_HATCH_CPP"):
+            self._logger.info("Skipping the build hook since SKIP_HATCH_CPP was set")
+            return
+
+        # Get build config class or use default
+        build_config_class = import_string(self.config["build-config-class"]) if "build-config-class" in self.config else HatchCppBuildConfig
+
+        # Instantiate build config
+        config = build_config_class(**self.config)
+
+        # Grab libraries and platform
+        libraries = config.libraries
+        platform = config.platform
+
+        # Get build plan class or use default
+        build_plan_class = import_string(self.config["build-plan-class"]) if "build-plan-class" in self.config else HatchCppBuildPlan
+
+        # Instantiate builder
+        build_plan = build_plan_class(libraries=libraries, platform=platform)
+
+        # Generate commands
+        build_plan.generate()
+
+        # Log commands if in verbose mode
+        if config.verbose:
+            for command in build_plan.commands:
+                self._logger.warning(command)
+
+        # Execute build plan
+        build_plan.execute()
+
+        # Perform any cleanup actions
+        build_plan.cleanup()
+
+        # force include libraries
+        for library in libraries:
+            name = library.get_qualified_name(build_plan.platform.platform)
+            build_data["force_include"][name] = name
+
+        if libraries:
+            build_data["pure_python"] = False
+            machine = sysplatform.machine()
+            version_major = sys.version_info.major
+            version_minor = sys.version_info.minor
+            # TODO abi3
+            if "darwin" in sys.platform:
+                os_name = "macosx_11_0"
+            elif "linux" in sys.platform:
+                os_name = "linux"
+            else:
+                os_name = "win"
+            if all([lib.py_limited_api for lib in libraries]):
+                build_data["tag"] = f"cp{version_major}{version_minor}-abi3-{os_name}_{machine}"
+            else:
+                build_data["tag"] = f"cp{version_major}{version_minor}-cp{version_major}{version_minor}-{os_name}_{machine}"

hatch_cpp/structs.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+from os import environ, system
+from pathlib import Path
+from re import match
+from shutil import which
+from sys import executable, platform as sys_platform
+from sysconfig import get_path
+from typing import Any, List, Literal, Optional
+
+from pydantic import AliasChoices, BaseModel, Field, field_validator, model_validator
+
+__all__ = (
+    "HatchCppBuildConfig",
+    "HatchCppLibrary",
+    "HatchCppPlatform",
+    "HatchCppBuildPlan",
+)
+
+BuildType = Literal["debug", "release"]
+CompilerToolchain = Literal["gcc", "clang", "msvc"]
+Language = Literal["c", "c++"]
+Binding = Literal["cpython", "pybind11", "nanobind"]
+Platform = Literal["linux", "darwin", "win32"]
+PlatformDefaults = {
+    "linux": {"CC": "gcc", "CXX": "g++", "LD": "ld"},
+    "darwin": {"CC": "clang", "CXX": "clang++", "LD": "ld"},
+    "win32": {"CC": "cl", "CXX": "cl", "LD": "link"},
+}
+
+
+class HatchCppLibrary(BaseModel, validate_assignment=True):
+    """A C++ library."""
+
+    name: str
+    sources: List[str]
+    language: Language = "c++"
+
+    binding: Binding = "cpython"
+    std: Optional[str] = None
+
+    include_dirs: List[str] = Field(default_factory=list, alias=AliasChoices("include_dirs", "include-dirs"))
+    library_dirs: List[str] = Field(default_factory=list, alias=AliasChoices("library_dirs", "library-dirs"))
+    libraries: List[str] = Field(default_factory=list)
+
+    extra_compile_args: List[str] = Field(default_factory=list, alias=AliasChoices("extra_compile_args", "extra-compile-args"))
+    extra_link_args: List[str] = Field(default_factory=list, alias=AliasChoices("extra_link_args", "extra-link-args"))
+    extra_objects: List[str] = Field(default_factory=list, alias=AliasChoices("extra_objects", "extra-objects"))
+
+    define_macros: List[str] = Field(default_factory=list, alias=AliasChoices("define_macros", "define-macros"))
+    undef_macros: List[str] = Field(default_factory=list, alias=AliasChoices("undef_macros", "undef-macros"))
+
+    export_symbols: List[str] = Field(default_factory=list, alias=AliasChoices("export_symbols", "export-symbols"))
+    depends: List[str] = Field(default_factory=list)
+
+    py_limited_api: Optional[str] = Field(default="", alias=AliasChoices("py_limited_api", "py-limited-api"))
+
+    @field_validator("py_limited_api", mode="before")
+    @classmethod
+    def check_py_limited_api(cls, value: Any) -> Any:
+        if value:
+            if not match(r"cp3\d", value):
+                raise ValueError("py-limited-api must be in the form of cp3X")
+        return value
+
+    def get_qualified_name(self, platform):
+        if platform == "win32":
+            suffix = "dll" if self.binding == "none" else "pyd"
+        elif platform == "darwin":
+            suffix = "dylib" if self.binding == "none" else "so"
+        else:
+            suffix = "so"
+        if self.py_limited_api and platform != "win32":
+            return f"{self.name}.abi3.{suffix}"
+        return f"{self.name}.{suffix}"
+
+    @model_validator(mode="after")
+    def check_binding_and_py_limited_api(self):
+        if self.binding == "pybind11" and self.py_limited_api:
+            raise ValueError("pybind11 does not support Py_LIMITED_API")
+        return self
+
+
+class HatchCppPlatform(BaseModel):
+    cc: str
+    cxx: str
+    ld: str
+    platform: Platform
+    toolchain: CompilerToolchain
+
+    @staticmethod
+    def default() -> HatchCppPlatform:
+        platform = environ.get("HATCH_CPP_PLATFORM", sys_platform)
+        CC = environ.get("CC", PlatformDefaults[platform]["CC"])
+        CXX = environ.get("CXX", PlatformDefaults[platform]["CXX"])
+        LD = environ.get("LD", PlatformDefaults[platform]["LD"])
+        if "gcc" in CC and "g++" in CXX:
+            toolchain = "gcc"
+        elif "clang" in CC and "clang++" in CXX:
+            toolchain = "clang"
+        elif "cl" in CC and "cl" in CXX:
+            toolchain = "msvc"
+        else:
+            raise Exception(f"Unrecognized toolchain: {CC}, {CXX}")
+
+        # Customizations
+        if which("ccache") and not environ.get("HATCH_CPP_DISABLE_CCACHE"):
+            CC = f"ccache {CC}"
+            CXX = f"ccache {CXX}"
+
+        # https://github.com/rui314/mold/issues/647
+        # if which("ld.mold"):
+        #     LD = which("ld.mold")
+        # elif which("ld.lld"):
+        #     LD = which("ld.lld")
+        return HatchCppPlatform(cc=CC, cxx=CXX, ld=LD, platform=platform, toolchain=toolchain)
+
+    def get_compile_flags(self, library: HatchCppLibrary, build_type: BuildType = "release") -> str:
+        flags = ""
+
+        # Python.h
+        library.include_dirs.append(get_path("include"))
+
+        if library.binding == "pybind11":
+            import pybind11
+
+            library.include_dirs.append(pybind11.get_include())
+            if not library.std:
+                library.std = "c++11"
+        elif library.binding == "nanobind":
+            import nanobind
+
+            library.include_dirs.append(nanobind.include_dir())
+            if not library.std:
+                library.std = "c++17"
+            library.sources.append(str(Path(nanobind.include_dir()).parent / "src" / "nb_combined.cpp"))
+            library.include_dirs.append(str((Path(nanobind.include_dir()).parent / "ext" / "robin_map" / "include")))
+
+        if library.py_limited_api:
+            if library.binding == "pybind11":
+                raise ValueError("pybind11 does not support Py_LIMITED_API")
+            library.define_macros.append(f"Py_LIMITED_API=0x0{library.py_limited_api[2]}0{hex(int(library.py_limited_api[3:]))[2:]}00f0")
+
+        # Toolchain-specific flags
+        if self.toolchain == "gcc":
+            flags += " " + " ".join(f"-I{d}" for d in library.include_dirs)
+            flags += " -fPIC"
+            flags += " " + " ".join(library.extra_compile_args)
+            flags += " " + " ".join(f"-D{macro}" for macro in library.define_macros)
+            flags += " " + " ".join(f"-U{macro}" for macro in library.undef_macros)
+            if library.std:
+                flags += f" -std={library.std}"
+        elif self.toolchain == "clang":
+            flags += " ".join(f"-I{d}" for d in library.include_dirs)
+            flags += " -fPIC"
+            flags += " " + " ".join(library.extra_compile_args)
+            flags += " " + " ".join(f"-D{macro}" for macro in library.define_macros)
+            flags += " " + " ".join(f"-U{macro}" for macro in library.undef_macros)
+            if library.std:
+                flags += f" -std={library.std}"
+        elif self.toolchain == "msvc":
+            flags += " ".join(f"/I{d}" for d in library.include_dirs)
+            flags += " " + " ".join(library.extra_compile_args)
+            flags += " " + " ".join(library.extra_link_args)
+            flags += " " + " ".join(library.extra_objects)
+            flags += " " + " ".join(f"/D{macro}" for macro in library.define_macros)
+            flags += " " + " ".join(f"/U{macro}" for macro in library.undef_macros)
+            flags += " /EHsc /DWIN32"
+            if library.std:
+                flags += f" /std:{library.std}"
+        # clean
+        while flags.count("  "):
+            flags = flags.replace("  ", " ")
+        return flags
+
+    def get_link_flags(self, library: HatchCppLibrary, build_type: BuildType = "release") -> str:
+        flags = ""
+        if self.toolchain == "gcc":
+            flags += " -shared"
+            flags += " " + " ".join(library.extra_link_args)
+            flags += " " + " ".join(library.extra_objects)
+            flags += " " + " ".join(f"-l{lib}" for lib in library.libraries)
+            flags += " " + " ".join(f"-L{lib}" for lib in library.library_dirs)
+            flags += f" -o {library.get_qualified_name(self.platform)}"
+            if self.platform == "darwin":
+                flags += " -undefined dynamic_lookup"
+            if "mold" in self.ld:
+                flags += f" -fuse-ld={self.ld}"
+            elif "lld" in self.ld:
+                flags += " -fuse-ld=lld"
+        elif self.toolchain == "clang":
+            flags += " -shared"
+            flags += " " + " ".join(library.extra_link_args)
+            flags += " " + " ".join(library.extra_objects)
+            flags += " " + " ".join(f"-l{lib}" for lib in library.libraries)
+            flags += " " + " ".join(f"-L{lib}" for lib in library.library_dirs)
+            flags += f" -o {library.get_qualified_name(self.platform)}"
+            if self.platform == "darwin":
+                flags += " -undefined dynamic_lookup"
+            if "mold" in self.ld:
+                flags += f" -fuse-ld={self.ld}"
+            elif "lld" in self.ld:
+                flags += " -fuse-ld=lld"
+        elif self.toolchain == "msvc":
+            flags += " " + " ".join(library.extra_link_args)
+            flags += " " + " ".join(library.extra_objects)
+            flags += " /LD"
+            flags += f" /Fe:{library.get_qualified_name(self.platform)}"
+            flags += " /link /DLL"
+            if (Path(executable).parent / "libs").exists():
+                flags += f" /LIBPATH:{str(Path(executable).parent / 'libs')}"
+            flags += " " + " ".join(f"{lib}.lib" for lib in library.libraries)
+            flags += " " + " ".join(f"/LIBPATH:{lib}" for lib in library.library_dirs)
+        # clean
+        while flags.count("  "):
+            flags = flags.replace("  ", " ")
+        return flags
+
+
+class HatchCppBuildPlan(BaseModel):
+    build_type: BuildType = "release"
+    libraries: List[HatchCppLibrary] = Field(default_factory=list)
+    platform: HatchCppPlatform = Field(default_factory=HatchCppPlatform.default)
+    commands: List[str] = Field(default_factory=list)
+
+    def generate(self):
+        self.commands = []
+        for library in self.libraries:
+            compile_flags = self.platform.get_compile_flags(library, self.build_type)
+            link_flags = self.platform.get_link_flags(library, self.build_type)
+            self.commands.append(
+                f"{self.platform.cc if library.language == 'c' else self.platform.cxx} {' '.join(library.sources)} {compile_flags} {link_flags}"
+            )
+        return self.commands
+
+    def execute(self):
+        for command in self.commands:
+            system(command)
+        return self.commands
+
+    def cleanup(self):
+        if self.platform.platform == "win32":
+            for temp_obj in Path(".").glob("*.obj"):
+                temp_obj.unlink()
+
+
+class HatchCppBuildConfig(BaseModel):
+    """Build config values for Hatch C++ Builder."""
+
+    verbose: Optional[bool] = Field(default=False)
+    libraries: List[HatchCppLibrary] = Field(default_factory=list)
+    platform: Optional[HatchCppPlatform] = Field(default_factory=HatchCppPlatform.default)

hatch_cpp/tests/test_project_basic/cpp/project/basic.cpp

@@ -0,0 +1,5 @@
+#include "project/basic.hpp"
+
+PyObject* hello(PyObject*, PyObject*) {
+    return PyUnicode_FromString("A string");
+}

hatch_cpp/tests/test_project_basic/cpp/project/basic.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include "Python.h"
+
+PyObject* hello(PyObject*, PyObject*);
+
+static PyMethodDef extension_methods[] = {
+  {"hello", (PyCFunction)hello, METH_NOARGS},
+  {nullptr, nullptr, 0, nullptr}
+};
+
+static PyModuleDef extension_module = {
+  PyModuleDef_HEAD_INIT, "extension", "extension", -1, extension_methods};
+
+PyMODINIT_FUNC PyInit_extension(void) {
+  Py_Initialize();
+  return PyModule_Create(&extension_module);
+}

hatch_cpp/tests/test_project_basic/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-basic"
+description = "Basic test project for hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.dll",
+    "project/*.dylib",
+    "project/*.so",
+]
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["project"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.hatch.build.hooks.hatch-cpp]
+verbose = true
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"]}
+]

hatch_cpp/tests/test_project_limited_api/cpp/project/basic.cpp

@@ -0,0 +1,5 @@
+#include "project/basic.hpp"
+
+PyObject* hello(PyObject*, PyObject*) {
+    return PyUnicode_FromString("A string");
+}

hatch_cpp/tests/test_project_limited_api/cpp/project/basic.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include "Python.h"
+
+PyObject* hello(PyObject*, PyObject*);
+
+static PyMethodDef extension_methods[] = {
+  {"hello", (PyCFunction)hello, METH_NOARGS},
+  {nullptr, nullptr, 0, nullptr}
+};
+
+static PyModuleDef extension_module = {
+  PyModuleDef_HEAD_INIT, "extension", "extension", -1, extension_methods};
+
+PyMODINIT_FUNC PyInit_extension(void) {
+  Py_Initialize();
+  return PyModule_Create(&extension_module);
+}

hatch_cpp/tests/test_project_limited_api/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-limtied-api"
+description = "Basic test project for hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.dll",
+    "project/*.dylib",
+    "project/*.so",
+]
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["project"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.hatch.build.hooks.hatch-cpp]
+verbose = true
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"], py-limited-api = "cp39"},
+]

hatch_cpp/tests/test_project_nanobind/cpp/project/basic.cpp

@@ -0,0 +1,2 @@
+#include "project/basic.hpp"
+

hatch_cpp/tests/test_project_nanobind/cpp/project/basic.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+NB_MODULE(extension, m) {
+    m.def("hello", []() { return "A string"; });
+}

hatch_cpp/tests/test_project_nanobind/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-nanobind"
+description = "Basic test project for hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.dll",
+    "project/*.dylib",
+    "project/*.so",
+]
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["project"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.hatch.build.hooks.hatch-cpp]
+verbose = true
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"], binding = "nanobind"},
+]

hatch_cpp/tests/test_project_override_classes/cpp/project/basic.cpp

@@ -0,0 +1,5 @@
+#include "project/basic.hpp"
+
+PyObject* hello(PyObject*, PyObject*) {
+    return PyUnicode_FromString("A string");
+}

hatch_cpp/tests/test_project_override_classes/cpp/project/basic.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include "Python.h"
+
+PyObject* hello(PyObject*, PyObject*);
+
+static PyMethodDef extension_methods[] = {
+  {"hello", (PyCFunction)hello, METH_NOARGS},
+  {nullptr, nullptr, 0, nullptr}
+};
+
+static PyModuleDef extension_module = {
+  PyModuleDef_HEAD_INIT, "extension", "extension", -1, extension_methods};
+
+PyMODINIT_FUNC PyInit_extension(void) {
+  Py_Initialize();
+  return PyModule_Create(&extension_module);
+}

hatch_cpp/tests/test_project_override_classes/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-override-classes"
+description = "Basic test project for hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.dll",
+    "project/*.dylib",
+    "project/*.so",
+]
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["project"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.hatch.build.hooks.hatch-cpp]
+build-config-class = "hatch_cpp.HatchCppBuildConfig"
+build-plan-class = "hatch_cpp.HatchCppBuildPlan"
+verbose = true
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"]}
+]

hatch_cpp/tests/test_project_pybind/cpp/project/basic.cpp

@@ -0,0 +1,6 @@
+#include "project/basic.hpp"
+
+std::string hello() {
+    return "A string";
+}
+

hatch_cpp/tests/test_project_pybind/cpp/project/basic.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include <pybind11/pybind11.h>
+#include <string>
+
+std::string hello();
+
+PYBIND11_MODULE(extension, m) {
+    m.def("hello", &hello);
+}

hatch_cpp/tests/test_project_pybind/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-pybind"
+description = "Basic test project for hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.dll",
+    "project/*.dylib",
+    "project/*.so",
+]
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["project"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.hatch.build.hooks.hatch-cpp]
+verbose = true
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"], binding="pybind11"},
+]

hatch_cpp/tests/test_projects.py

@@ -0,0 +1,46 @@
+from os import listdir
+from pathlib import Path
+from shutil import rmtree
+from subprocess import check_call
+from sys import modules, path, platform
+
+import pytest
+
+
+class TestProject:
+    @pytest.mark.parametrize(
+        "project", ["test_project_basic", "test_project_override_classes", "test_project_pybind", "test_project_nanobind", "test_project_limited_api"]
+    )
+    def test_basic(self, project):
+        # cleanup
+        rmtree(f"hatch_cpp/tests/{project}/project/extension.so", ignore_errors=True)
+        rmtree(f"hatch_cpp/tests/{project}/project/extension.pyd", ignore_errors=True)
+        modules.pop("project", None)
+        modules.pop("project.extension", None)
+
+        # compile
+        check_call(
+            [
+                "hatchling",
+                "build",
+                "--hooks-only",
+            ],
+            cwd=f"hatch_cpp/tests/{project}",
+        )
+
+        # assert built
+
+        if project == "test_project_limited_api" and platform != "win32":
+            assert "extension.abi3.so" in listdir(f"hatch_cpp/tests/{project}/project")
+        else:
+            if platform == "win32":
+                assert "extension.pyd" in listdir(f"hatch_cpp/tests/{project}/project")
+            else:
+                assert "extension.so" in listdir(f"hatch_cpp/tests/{project}/project")
+
+        # import
+        here = Path(__file__).parent / project
+        path.insert(0, str(here))
+        import project.extension
+
+        assert project.extension.hello() == "A string"

hatch_cpp/tests/test_structs.py

@@ -0,0 +1,26 @@
+import pytest
+from pydantic import ValidationError
+
+from hatch_cpp.structs import HatchCppLibrary, HatchCppPlatform
+
+
+class TestStructs:
+    def test_validate_py_limited_api(self):
+        with pytest.raises(ValidationError):
+            library = HatchCppLibrary(
+                name="test",
+                sources=["test.cpp"],
+                py_limited_api="42",
+            )
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            py_limited_api="cp39",
+        )
+        assert library.py_limited_api == "cp39"
+        platform = HatchCppPlatform.default()
+        flags = platform.get_compile_flags(library)
+        assert "-DPy_LIMITED_API=0x030900f0" in flags or "/DPy_LIMITED_API=0x030900f0" in flags
+
+        with pytest.raises(ValidationError):
+            library.binding = "pybind11"

hatch_cpp/utils.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from functools import lru_cache
+
+from pydantic import ImportString, TypeAdapter
+
+_import_string_adapter = TypeAdapter(ImportString)
+
+
+@lru_cache(maxsize=None)
+def import_string(input_string: str):
+    return _import_string_adapter.validate_python(input_string)
+
+
+# import multiprocessing
+# import os
+# import os.path
+# import platform
+# import subprocess
+# import sys
+# from shutil import which
+# from skbuild import setup
+
+# CSP_USE_VCPKG = os.environ.get("CSP_USE_VCPKG", "1").lower() in ("1", "on")
+# # Allow arg to override default / env
+# if "--csp-no-vcpkg" in sys.argv:
+#     CSP_USE_VCPKG = False
+#     sys.argv.remove("--csp-no-vcpkg")
+
+# # CMake Options
+# CMAKE_OPTIONS = (
+#     ("CSP_BUILD_NO_CXX_ABI", "0"),
+#     ("CSP_BUILD_TESTS", "1"),
+#     ("CSP_MANYLINUX", "0"),
+#     ("CSP_BUILD_KAFKA_ADAPTER", "1"),
+#     ("CSP_BUILD_PARQUET_ADAPTER", "1"),
+#     ("CSP_BUILD_WS_CLIENT_ADAPTER", "1"),
+#     # NOTE:
+#     # - omit vcpkg, need to test for presence
+#     # - omit ccache, need to test for presence
+#     # - omit coverage/gprof, not implemented
+# )
+
+# if sys.platform == "linux":
+#     VCPKG_TRIPLET = "x64-linux"
+# elif sys.platform == "win32":
+#     VCPKG_TRIPLET = "x64-windows-static-md"
+# else:
+#     VCPKG_TRIPLET = None
+
+# # This will be used for e.g. the sdist
+# if CSP_USE_VCPKG:
+#     if not os.path.exists("vcpkg"):
+#         subprocess.call(["git", "clone", "https://github.com/Microsoft/vcpkg.git"])
+#     if not os.path.exists("vcpkg/ports"):
+#         subprocess.call(["git", "submodule", "update", "--init", "--recursive"])
+#     if not os.path.exists("vcpkg/buildtrees"):
+#         subprocess.call(["git", "pull"], cwd="vcpkg")
+#         args = ["install"]
+#         if VCPKG_TRIPLET is not None:
+#             args.append(f"--triplet={VCPKG_TRIPLET}")
+
+#         if os.name == "nt":
+#             subprocess.call(["bootstrap-vcpkg.bat"], cwd="vcpkg", shell=True)
+#             subprocess.call(["vcpkg.bat"] + args, cwd="vcpkg", shell=True)
+#         else:
+#             subprocess.call(["./bootstrap-vcpkg.sh"], cwd="vcpkg")
+#             subprocess.call(["./vcpkg"] + args, cwd="vcpkg")
+
+
+# python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+# cmake_args = [f"-DCSP_PYTHON_VERSION={python_version}"]
+# vcpkg_toolchain_file = os.path.abspath(
+#     os.environ.get(
+#         "CSP_VCPKG_PATH",
+#         os.path.join("vcpkg/scripts/buildsystems/vcpkg.cmake"),
+#     )
+# )
+
+# if CSP_USE_VCPKG and os.path.exists(vcpkg_toolchain_file):
+#     cmake_args.extend(
+#         [
+#             "-DCMAKE_TOOLCHAIN_FILE={}".format(vcpkg_toolchain_file),
+#             "-DCSP_USE_VCPKG=ON",
+#         ]
+#     )
+
+#     if VCPKG_TRIPLET is not None:
+#         cmake_args.append(f"-DVCPKG_TARGET_TRIPLET={VCPKG_TRIPLET}")
+# else:
+#     cmake_args.append("-DCSP_USE_VCPKG=OFF")
+
+# if "CXX" in os.environ:
+#     cmake_args.append(f"-DCMAKE_CXX_COMPILER={os.environ['CXX']}")
+
+# if "DEBUG" in os.environ:
+#     cmake_args.append("-DCMAKE_BUILD_TYPE=Debug")
+
+# if platform.system() == "Windows":
+#     import distutils.msvccompiler as dm
+
+#     # https://wiki.python.org/moin/WindowsCompilers#Microsoft_Visual_C.2B-.2B-_14.0_with_Visual_Studio_2015_.28x86.2C_x64.2C_ARM.29
+#     msvc = {
+#         "12": "Visual Studio 12 2013",
+#         "14": "Visual Studio 14 2015",
+#         "14.0": "Visual Studio 14 2015",
+#         "14.1": "Visual Studio 15 2017",
+#         "14.2": "Visual Studio 16 2019",
+#         "14.3": "Visual Studio 17 2022",
+#     }.get(str(dm.get_build_version()), "Visual Studio 15 2017")
+#     cmake_args.extend(
+#         [
+#             "-G",
+#             os.environ.get("CSP_GENERATOR", msvc),
+#         ]
+#     )
+
+# for cmake_option, default in CMAKE_OPTIONS:
+#     if os.environ.get(cmake_option, default).lower() in ("1", "on"):
+#         cmake_args.append(f"-D{cmake_option}=ON")
+#     else:
+#         cmake_args.append(f"-D{cmake_option}=OFF")
+
+# if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+#     os.environ["CMAKE_BUILD_PARALLEL_LEVEL"] = str(multiprocessing.cpu_count())
+
+# if platform.system() == "Darwin":
+#     os.environ["MACOSX_DEPLOYMENT_TARGET"] = os.environ.get("OSX_DEPLOYMENT_TARGET", "10.15")
+#     cmake_args.append(f'-DCMAKE_OSX_DEPLOYMENT_TARGET={os.environ.get("OSX_DEPLOYMENT_TARGET", "10.15")}')
+
+# if which("ccache") and os.environ.get("CSP_USE_CCACHE", "") != "0":
+#     cmake_args.append("-DCSP_USE_CCACHE=On")

hatch_cpp-0.1.6.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: hatch-cpp
+Version: 0.1.6
+Summary: Hatch plugin for C++ builds
+Project-URL: Repository, https://github.com/python-project-templates/hatch-cpp
+Project-URL: Homepage, https://github.com/python-project-templates/hatch-cpp
+Author-email: the hatch-cpp authors <t.paine154@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: build,c++,cmake,cpp,hatch,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Requires-Dist: hatchling>=1.20
+Requires-Dist: pydantic
+Provides-Extra: develop
+Requires-Dist: build; extra == 'develop'
+Requires-Dist: bump-my-version; extra == 'develop'
+Requires-Dist: check-manifest; extra == 'develop'
+Requires-Dist: nanobind; extra == 'develop'
+Requires-Dist: pybind11; extra == 'develop'
+Requires-Dist: pytest; extra == 'develop'
+Requires-Dist: pytest-cov; extra == 'develop'
+Requires-Dist: ruff<0.9,>=0.3; extra == 'develop'
+Requires-Dist: twine; extra == 'develop'
+Requires-Dist: wheel; extra == 'develop'
+Description-Content-Type: text/markdown
+
+# hatch-cpp
+
+Hatch plugin for C++ builds
+
+[![Build Status](https://github.com/python-project-templates/hatch-cpp/actions/workflows/build.yml/badge.svg?branch=main&event=push)](https://github.com/python-project-templates/hatch-cpp/actions/workflows/build.yml)
+[![codecov](https://codecov.io/gh/python-project-templates/hatch-cpp/branch/main/graph/badge.svg)](https://codecov.io/gh/python-project-templates/hatch-cpp)
+[![License](https://img.shields.io/github/license/python-project-templates/hatch-cpp)](https://github.com/python-project-templates/hatch-cpp)
+[![PyPI](https://img.shields.io/pypi/v/hatch-cpp.svg)](https://pypi.python.org/pypi/hatch-cpp)
+
+## Overview
+
+A simple, extensible C++ build plugin for [hatch](https://hatch.pypa.io/latest/).
+
+```toml
+[tool.hatch.build.hooks.hatch-cpp]
+libraries = [
+    {name = "project/extension", sources = ["cpp/project/basic.cpp"], include-dirs = ["cpp"]}
+]
+```
+
+For more complete systems, see:
+- [scikit-build-core](https://github.com/scikit-build/scikit-build-core)
+- [setuptools](https://setuptools.pypa.io/en/latest/userguide/ext_modules.html)
+
+## Environment Variables
+| Name | Default | Description |
+|:-----|:--------|:------------|
+|`CC`| | |
+|`CXX`| | |
+|`LD`| | |
+|`HATCH_CPP_PLATFORM`| | |
+|`HATCH_CPP_DISABLE_CCACHE`| | |
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

hatch_cpp-0.1.6.dist-info/RECORD

@@ -0,0 +1,34 @@
+hatch_cpp/__init__.py,sha256=GpnnPr3BgwAuiIJ5m9xconjyECZPRPhuZQ9Q7HzWR0o,129
+hatch_cpp/hooks.py,sha256=SQkF5WJIgzw-8rvlTzuQvBqdP6K3fHgnh6CZOZFag50,203
+hatch_cpp/plugin.py,sha256=iEDP6U7T_3G3m2ONCoYcMD3XNLq6ob_s_dn7AbtwnZ8,3238
+hatch_cpp/structs.py,sha256=o_XtXWVs0Zv0IARLY8R3NEbNqT2sAHQf7GNMIFggrKg,10681
+hatch_cpp/utils.py,sha256=topOiT6biVzisNAEKHvYzU-JdA56B3LA61jbU9fjAEQ,4444
+hatch_cpp/tests/test_projects.py,sha256=zE0XOPOuaQPfdvjgZRTPnsZ5gzK2shFPqKaPXkb5oSc,1509
+hatch_cpp/tests/test_structs.py,sha256=Qv2uBHwxf0edR8FIOnA2gj-AJgdsiDKt4vyK8HChAHg,851
+hatch_cpp/tests/test_project_basic/pyproject.toml,sha256=eqM1UVpNmJWDfsuO18ZG_VOV9I4tAWgsM5Dhf49X8Nc,694
+hatch_cpp/tests/test_project_basic/cpp/project/basic.cpp,sha256=gQ2nmdLqIdgaqxSKvkN_vbp6Iv_pAoVIHETXPRnALb0,117
+hatch_cpp/tests/test_project_basic/cpp/project/basic.hpp,sha256=SO5GhPj8k3RzWrfH37lFSDc8w1Vf3yqTUhxmr1hnoko,422
+hatch_cpp/tests/test_project_basic/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/tests/test_project_limited_api/pyproject.toml,sha256=k_2y7YpZP5I-KPvKOZLmnHqoKXVE2oVM8fjxtRKoTo0,726
+hatch_cpp/tests/test_project_limited_api/cpp/project/basic.cpp,sha256=gQ2nmdLqIdgaqxSKvkN_vbp6Iv_pAoVIHETXPRnALb0,117
+hatch_cpp/tests/test_project_limited_api/cpp/project/basic.hpp,sha256=SO5GhPj8k3RzWrfH37lFSDc8w1Vf3yqTUhxmr1hnoko,422
+hatch_cpp/tests/test_project_limited_api/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/tests/test_project_nanobind/pyproject.toml,sha256=_QV3uW2UWjbiBOKiEfMQKkDyG3VlZui-GE6PSYokdHo,720
+hatch_cpp/tests/test_project_nanobind/cpp/project/basic.cpp,sha256=L4v9AUveWWQX8Z2GMRREsEGLz-A_NCeuX0KiyppDmbc,30
+hatch_cpp/tests/test_project_nanobind/cpp/project/basic.hpp,sha256=AK2FKdlqBwH5jnRUdJXSbWvRr-gSVsUKSG0PiYNsW7A,155
+hatch_cpp/tests/test_project_nanobind/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/tests/test_project_override_classes/pyproject.toml,sha256=ykoZnutSWLYIZQ0M5K86tcy7P1sHamzRd-R-bJKuxsk,807
+hatch_cpp/tests/test_project_override_classes/cpp/project/basic.cpp,sha256=gQ2nmdLqIdgaqxSKvkN_vbp6Iv_pAoVIHETXPRnALb0,117
+hatch_cpp/tests/test_project_override_classes/cpp/project/basic.hpp,sha256=SO5GhPj8k3RzWrfH37lFSDc8w1Vf3yqTUhxmr1hnoko,422
+hatch_cpp/tests/test_project_override_classes/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/tests/test_project_pybind/pyproject.toml,sha256=3IVlSprxx8XaC36s6OSgKr-OiSPn6cH6nX8pbp10suM,716
+hatch_cpp/tests/test_project_pybind/cpp/project/basic.cpp,sha256=MT3eCSQKr4guI3XZHV8kw8PoBGC6LEK8ClxnNMBnvnI,78
+hatch_cpp/tests/test_project_pybind/cpp/project/basic.hpp,sha256=LZSfCfhLY_91MBOxtnvDk7DcceO-9GhCHKpMnAjGe18,146
+hatch_cpp/tests/test_project_pybind/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/toolchains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp/toolchains/cmake.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_cpp-0.1.6.dist-info/METADATA,sha256=xxJ65xK090LytyqWJP48Gy4rQLOGJNIprM5UC2e8_gA,3003
+hatch_cpp-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hatch_cpp-0.1.6.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
+hatch_cpp-0.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hatch_cpp-0.1.6.dist-info/RECORD,,

hatch_cpp-0.1.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hatch_cpp-0.1.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hatch]
+cpp = hatch_cpp.hooks

hatch_cpp-0.1.6.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.