hatch-cpp 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

hatch_cpp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.2"
+__version__ = "0.6.1"
 
 from .config import *
 from .hooks import *

hatch_cpp/config.py

@@ -1,12 +1,33 @@
 from __future__ import annotations
 
+from importlib.machinery import EXTENSION_SUFFIXES
 from os import environ, system as system_call
 from pathlib import Path
 
+from hatch_native import (
+    ExternalLibrary,
+    LibraryValidationConfig,
+    check_exports,
+    check_headers,
+    prefixed_header_symbols,
+    resolve_external_library,
+    resolve_library_source,
+    run_validation_command,
+    shared_library_name,
+    write_artifact_manifest,
+)
 from pkn import getSimpleLogger
-from pydantic import BaseModel, Field, model_validator
+from pydantic import AliasChoices, BaseModel, Field, PrivateAttr, model_validator
 
-from .toolchains import BuildType, HatchCppCmakeConfiguration, HatchCppLibrary, HatchCppPlatform, HatchCppVcpkgConfiguration, Toolchain
+from .toolchains import (
+    BuildType,
+    HatchCppArtifact,
+    HatchCppCmakeConfiguration,
+    HatchCppLibrary,
+    HatchCppPlatform,
+    HatchCppVcpkgConfiguration,
+    Toolchain,
+)
 
 __all__ = (
     "HatchCppBuildConfig",
@@ -25,8 +46,20 @@ class HatchCppBuildConfig(BaseModel):
     name: str | None = Field(default=None)
     libraries: list[HatchCppLibrary] = Field(default_factory=list)
     cmake: HatchCppCmakeConfiguration | None = Field(default=None)
-    platform: HatchCppPlatform | None = Field(default_factory=HatchCppPlatform.default)
+    platform: HatchCppPlatform = Field(default_factory=HatchCppPlatform.default)
     vcpkg: HatchCppVcpkgConfiguration | None = Field(default_factory=HatchCppVcpkgConfiguration)
+    library_source: str = Field(
+        default="bundled",
+        validation_alias=AliasChoices("library-source", "library_source"),
+        description="How libraries named in depends are provided: bundled, external, or direct. Overridden by HATCH_CPP_LIBRARY_SOURCE.",
+    )
+    artifacts: list[HatchCppArtifact] = Field(default_factory=list)
+    artifact_manifest: bool = Field(default=False, validation_alias=AliasChoices("artifact-manifest", "artifact_manifest"))
+    artifact_manifest_destination: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("artifact-manifest-destination", "artifact_manifest_destination"),
+        description="Wheel-relative path of the artifact manifest JSON, such as project/lib/hatch-cpp-artifacts.json.",
+    )
 
     @model_validator(mode="wrap")
     @classmethod
@@ -50,6 +83,16 @@ class HatchCppBuildConfig(BaseModel):
         model = handler(data)
         if model.cmake and model.libraries:
             raise ValueError("Must not provide libraries when using cmake toolchain.")
+        declared: dict[str, HatchCppLibrary] = {}
+        for library in model.libraries:
+            if library.python_package is not None:
+                raise ValueError(f"Library '{library.name}' sets python-package, which hatch-cpp does not support yet.")
+            for name in library.depends:
+                if name not in declared or declared[name].binding != "generic":
+                    raise ValueError(f"Library '{library.name}' depends on '{name}', which must be a generic library declared before it.")
+            declared[library.name] = library
+        if model.artifact_manifest and not model.artifact_manifest_destination:
+            raise ValueError("artifact-manifest requires artifact-manifest-destination.")
         return model
 
 
@@ -58,6 +101,48 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
     commands: list[str] = Field(default_factory=list)
 
     _active_toolchains: list[Toolchain] = []
+    _external_libraries: dict[str, ExternalLibrary] = PrivateAttr(default_factory=dict)
+    _skipped_libraries: set[str] = PrivateAttr(default_factory=set)
+
+    def built_libraries(self) -> list[HatchCppLibrary]:
+        """Libraries this build compiles; external and direct mode skip the ones other entries depend on."""
+        return [library for library in self.libraries if library.name not in self._skipped_libraries]
+
+    def _resolve_external(self, library: HatchCppLibrary) -> ExternalLibrary:
+        root = environ.get("HATCH_CPP_LIBRARY_ROOT") or (str(library.library_root) if library.library_root is not None else None)
+        name = Path(library.name).name
+        if name.startswith("lib") and len(name) > 3:
+            name = name[3:]
+        return resolve_external_library(
+            name,
+            label=library.name,
+            platform=self.platform.platform,
+            root_env_var="HATCH_CPP_LIBRARY_ROOT",
+            root=Path(root).resolve() if root else None,
+            pkg_config=library.pkg_config,
+        )
+
+    def _consumer(self, library: HatchCppLibrary, source: str) -> tuple[HatchCppLibrary, list[HatchCppLibrary]]:
+        """The library to compile and the libraries it links, after applying the library-source mode to its depends."""
+        dependencies = [next(other for other in self.libraries if other.name == name) for name in library.depends]
+        if not dependencies or source == "bundled":
+            return library, dependencies
+        if source == "external":
+            externals = [self._external_libraries[dependency.name] for dependency in dependencies]
+            return library.model_copy(
+                update={
+                    "include_dirs": [*library.include_dirs, *(str(external.include_dir) for external in externals if external.include_dir)],
+                    "library_dirs": [*library.library_dirs, *(str(external.library_dir) for external in externals)],
+                    "libraries": [*library.libraries, *(external.link_name for external in externals)],
+                }
+            ), []
+        return library.model_copy(
+            update={
+                "sources": [*library.sources, *(path for dependency in dependencies for path in dependency.sources)],
+                "include_dirs": [*library.include_dirs, *(path for dependency in dependencies for path in dependency.include_dirs)],
+                "define_macros": [*library.define_macros, *(macro for dependency in dependencies for macro in dependency.define_macros)],
+            }
+        ), []
 
     def generate(self):
         self.commands = []
@@ -72,7 +157,7 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
                 self._active_toolchains.append("vcpkg")
             else:
                 log.warning("HATCH_CPP_VCPKG=1 set but no vcpkg configuration found; ignoring.")
-        elif vcpkg_override != "0" and self.vcpkg and Path(self.vcpkg.vcpkg).exists():
+        elif vcpkg_override != "0" and self.vcpkg and self.vcpkg.vcpkg and Path(self.vcpkg.vcpkg).exists():
             self._active_toolchains.append("vcpkg")
 
         if self.libraries:
@@ -87,27 +172,40 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
 
         # Collect toolchain commands
         if "vcpkg" in self._active_toolchains:
+            assert self.vcpkg is not None
             self.commands.extend(self.vcpkg.generate(self))
 
         if "vanilla" in self._active_toolchains:
             if "vcpkg" in self._active_toolchains:
                 log.warning("vcpkg toolchain is active; ensure that your compiler is configured to use vcpkg includes and libs.")
 
+            source = resolve_library_source(self.library_source, env_var="HATCH_CPP_LIBRARY_SOURCE")
+            if source == "static":
+                raise ValueError("library-source 'static' is not supported by hatch-cpp; use bundled, external, or direct.")
+            linked = {name for library in self.libraries for name in library.depends}
+            self._external_libraries = {}
+            self._skipped_libraries = set() if source == "bundled" else linked
             for library_index, library in enumerate(self.libraries):
+                if library.name in self._skipped_libraries:
+                    if source == "external":
+                        self._external_libraries[library.name] = self._resolve_external(library)
+                    continue
+                library, dependencies = self._consumer(library, source)
                 compile_flags = self.platform.get_compile_flags(library, self.build_type)
-                link_flags = self.platform.get_link_flags(library, self.build_type)
+                link_flags = self.platform.get_link_flags(library, self.build_type, dependencies)
                 compiler = self.platform.cc if library.language == "c" else self.platform.cxx
                 if self.platform.platform == "emscripten":
                     objects = []
                     for source_index, source in enumerate(library.sources):
-                        obj = Path("build/hatch-cpp") / f"{library_index}-{source_index}-{Path(source).stem}.o"
-                        objects.append(str(obj))
+                        obj = f"build/hatch-cpp/{library_index}-{source_index}-{Path(source).stem}.o"
+                        objects.append(obj)
                         self.commands.append(f"{compiler} -c {source} {compile_flags} -o {obj}")
                     self.commands.append(f"{compiler} {' '.join(objects)} {link_flags}")
                 else:
                     self.commands.append(f"{compiler} {' '.join(library.sources)} {compile_flags} {link_flags}")
 
         if "cmake" in self._active_toolchains:
+            assert self.cmake is not None
             self.commands.extend(self.cmake.generate(self))
 
         return self.commands
@@ -115,6 +213,9 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
     def execute(self):
         if self.platform.platform == "emscripten" and "vanilla" in self._active_toolchains:
             Path("build/hatch-cpp").mkdir(parents=True, exist_ok=True)
+        if "vanilla" in self._active_toolchains:
+            for library in self.built_libraries():
+                Path(self._library_output(library)).parent.mkdir(parents=True, exist_ok=True)
         for command in self.commands:
             ret = system_call(command)
             if ret != 0:
@@ -125,3 +226,91 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
         if self.platform.platform == "win32":
             for temp_obj in Path(".").glob("*.obj"):
                 temp_obj.unlink()
+
+    def _library_output(self, library: HatchCppLibrary) -> str:
+        return library.get_qualified_name(self.platform.platform)
+
+    def _artifact_path(self, artifact: HatchCppArtifact, packaged: list[str]) -> str:
+        if artifact.path:
+            return artifact.path
+        library = next((library for library in self.libraries if library.name == artifact.name), None)
+        if library is not None:
+            return self._library_output(library)
+        filename = shared_library_name(Path(artifact.name).name, platform=self.platform.platform)
+        matches = [path for path in packaged if Path(path).name == filename]
+        if len(matches) != 1:
+            found = ", ".join(matches) if matches else "none"
+            raise FileNotFoundError(f"Artifact '{artifact.name}' needs a path: expected one packaged '{filename}', found {found}.")
+        return matches[0]
+
+    def validation_targets(self, packaged: list[str]) -> list[tuple[str, LibraryValidationConfig, str]]:
+        """Libraries with validation fields set, plus every `artifacts` entry, as (label, config, project-relative path)."""
+        targets: list[tuple[str, LibraryValidationConfig, str]] = []
+        for library in self.libraries:
+            if not _has_validation(library):
+                continue
+            if library.name in self._external_libraries:
+                targets.append((library.name, library, str(self._external_libraries[library.name].library)))
+            elif library.name not in self._skipped_libraries:
+                targets.append((library.name, library, self._library_output(library)))
+        targets.extend((artifact.name, artifact, self._artifact_path(artifact, packaged)) for artifact in self.artifacts)
+        return targets
+
+    def validate_artifacts(self, root: Path, packaged: list[str]) -> None:
+        """Check headers, ABI strings, and exports of each validation target, then run its validation commands."""
+        for label, config, relative in self.validation_targets(packaged):
+            library = root / relative
+            if not library.is_file():
+                raise FileNotFoundError(f"Artifact '{label}' library was not built: {relative}")
+            headers = check_headers(config.expected_headers, config.expected_abi_strings, base=root, label=label)
+            expected = list(dict.fromkeys([*config.expected_symbols, *prefixed_header_symbols(headers, config.header_symbol_prefix, label=label)]))
+            check_exports(library, expected=expected, load=config.validate_artifact, label=label, display_path=relative)
+            tokens = {"name": label, "path": str(library), "header": str(headers[0]) if headers else ""}
+            for command in config.validation_commands:
+                env = {**environ, **{key: value.format(**tokens) for key, value in command.env.items()}}
+                env.update({"HATCH_CPP_ARTIFACT_NAME": label, "HATCH_CPP_ARTIFACT_PATH": str(library)})
+                cwd = root / command.working_directory if command.working_directory else root
+                run_validation_command([value.format(**tokens) for value in command.command], cwd=cwd, env=env, label=label)
+
+    def write_manifest(self, root: Path, packaged: list[str]) -> str | None:
+        """Write the manifest of packaged binaries under the project root and return its relative path."""
+        if not self.artifact_manifest:
+            return None
+        assert self.artifact_manifest_destination is not None
+        records = [
+            {
+                "name": Path(path).name,
+                "role": _artifact_role(path, self.platform.platform),
+                "platform": self.platform.platform,
+                "profile": self.build_type,
+                "destination": Path(path).as_posix(),
+            }
+            for path in sorted(packaged)
+        ]
+        write_artifact_manifest(root / self.artifact_manifest_destination, module=self.name or "", records=records)
+        return self.artifact_manifest_destination
+
+
+def _has_validation(config: LibraryValidationConfig) -> bool:
+    return bool(
+        config.expected_symbols
+        or config.expected_headers
+        or config.expected_abi_strings
+        or config.header_symbol_prefix
+        or config.validate_artifact
+        or config.validation_commands
+    )
+
+
+def _artifact_role(path: str, platform: str) -> str:
+    """Classify a packaged binary: a Python extension module or a plain shared library."""
+    filename = Path(path).name
+    if filename.endswith(".pyd"):
+        return "python-extension"
+    if platform != "win32" and filename.startswith("lib"):
+        return "library"
+    if any(filename.endswith(suffix) for suffix in EXTENSION_SUFFIXES if suffix != ".so") or ".abi3." in filename:
+        return "python-extension"
+    if filename.endswith(".so") and platform in ("linux", "darwin", "emscripten"):
+        return "python-extension"
+    return "library"

hatch_cpp/plugin.py

@@ -88,9 +88,12 @@ class HatchCppBuildHook(BuildHookInterface):
 
         if build_plan.libraries:
             # force include libraries
-            for library in build_plan.libraries:
+            for library in build_plan.built_libraries():
                 name = library.get_qualified_name(build_plan.platform.platform)
                 build_data["force_include"][name] = name
+                import_library = Path(name).with_suffix(".lib")
+                if build_plan.platform.platform == "win32" and library.binding == "generic" and import_library.is_file():
+                    build_data["force_include"][import_library.as_posix()] = import_library.as_posix()
 
             build_data["pure_python"] = False
             machine = platform_machine()
@@ -101,9 +104,10 @@ class HatchCppBuildHook(BuildHookInterface):
                 machine,
                 version_major,
                 version_minor,
-                all(lib.py_limited_api for lib in build_plan.libraries),
+                all(lib.py_limited_api for lib in build_plan.built_libraries()),
             )
         else:
+            assert build_plan.cmake is not None
             build_data["pure_python"] = False
             machine = platform_machine()
             version_major = version_info.major
@@ -119,5 +123,11 @@ class HatchCppBuildHook(BuildHookInterface):
                 if path.suffix in (".pyd", ".dll", ".so", ".dylib"):
                     build_data["force_include"][str(path)] = str(path)
 
+        packaged = list(build_data["force_include"])
+        build_plan.validate_artifacts(Path(self.root), packaged)
+        manifest = build_plan.write_manifest(Path(self.root), packaged)
+        if manifest is not None:
+            build_data["force_include"][manifest] = manifest
+
         for path in build_data["force_include"]:
             self._logger.info(f"Force include: {path}")

hatch_cpp/tests/test_hatch_build.py

@@ -1,3 +1,4 @@
+from importlib import import_module
 from os import listdir
 from pathlib import Path
 from shutil import rmtree
@@ -41,6 +42,6 @@ class TestHatchBuild:
         # import
         here = Path(__file__).parent / project
         path.insert(0, str(here))
-        import project.extension
+        extension = import_module("project.extension")
 
-        assert project.extension.hello() == "A string"
+        assert extension.hello() == "A string"

hatch_cpp/tests/test_hook_registration.py

@@ -1,4 +1,5 @@
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+from hatchling.metadata.core import ProjectMetadata
 
 from hatch_cpp.hooks import hatch_register_build_hook
 
@@ -10,7 +11,7 @@ def test_registered_build_hook_accepts_hatchling_configuration(tmp_path):
         root=str(tmp_path),
         config=config,
         build_config=None,
-        metadata=None,
+        metadata=ProjectMetadata(str(tmp_path), None, {"project": {"name": "project", "version": "0.1.0"}}),
         directory=str(tmp_path),
         target_name="wheel",
     )

hatch_cpp/tests/test_project_c_abi_library/cpp/demo.c

@@ -0,0 +1,5 @@
+#include "demo/demo.h"
+
+int demo_abi_version(void) { return DEMO_ABI_VERSION; }
+
+int demo_answer(void) { return 42; }

hatch_cpp/tests/test_project_c_abi_library/cpp/extension.c

@@ -0,0 +1,11 @@
+#include <Python.h>
+
+#include "demo/demo.h"
+
+static PyObject *answer(PyObject *self, PyObject *args) { return PyLong_FromLong(demo_answer()); }
+
+static PyMethodDef methods[] = {{"answer", answer, METH_NOARGS, NULL}, {NULL, NULL, 0, NULL}};
+
+static struct PyModuleDef module = {PyModuleDef_HEAD_INIT, "extension", NULL, -1, methods};
+
+PyMODINIT_FUNC PyInit_extension(void) { return PyModule_Create(&module); }

hatch_cpp/tests/test_project_c_abi_library/cpp/include/demo/demo.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#define DEMO_ABI_VERSION 1
+
+#if defined(_WIN32) && defined(DEMO_BUILD)
+#define DEMO_API __declspec(dllexport)
+#elif defined(_WIN32)
+#define DEMO_API __declspec(dllimport)
+#else
+#define DEMO_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DEMO_API int demo_abi_version(void);
+DEMO_API int demo_answer(void);
+
+#ifdef __cplusplus
+}
+#endif

hatch_cpp/tests/test_project_c_abi_library/project/__init__.py

@@ -0,0 +1,5 @@
+import os
+import sys
+
+if sys.platform == "win32":
+    os.add_dll_directory(os.path.join(os.path.dirname(__file__), "lib"))

hatch_cpp/tests/test_project_c_abi_library/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-c-abi-library"
+description = "C ABI library validated by hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.pyd",
+    "project/*.so",
+    "project/lib/*.lib",
+    "project/lib/*.dll",
+    "project/lib/*.dylib",
+    "project/lib/*.so",
+    "project/lib/*.json",
+]
+
+[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
+artifact-manifest = true
+artifact-manifest-destination = "project/lib/hatch-cpp-artifacts.json"
+
+[[tool.hatch.build.hooks.hatch-cpp.libraries]]
+name = "project/lib/libdemo"
+sources = ["cpp/demo.c"]
+language = "c"
+binding = "generic"
+include-dirs = ["cpp/include"]
+define-macros = ["DEMO_BUILD"]
+expected-headers = ["cpp/include/demo/demo.h"]
+header-symbol-prefix = "demo_"
+expected-abi-strings = ["DEMO_ABI_VERSION 1"]
+validate = true
+
+[[tool.hatch.build.hooks.hatch-cpp.libraries]]
+name = "project/extension"
+sources = ["cpp/extension.c"]
+language = "c"
+include-dirs = ["cpp/include"]
+depends = ["project/lib/libdemo"]

hatch_cpp/tests/test_project_cmake_c_abi/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.20.0)
+project(hatch-cpp-test-project-cmake-c-abi VERSION "0.1.0" LANGUAGES C)
+
+set(CMAKE_INSTALL_NAME_DIR "@rpath")
+
+add_library(demo SHARED cpp/demo.c)
+target_include_directories(demo PUBLIC "${CMAKE_SOURCE_DIR}/cpp/include")
+target_compile_definitions(demo PRIVATE DEMO_BUILD)
+set_target_properties(demo PROPERTIES PUBLIC_HEADER cpp/include/demo/demo.h)
+install(TARGETS demo
+        LIBRARY DESTINATION project/lib
+        RUNTIME DESTINATION project/lib
+        ARCHIVE DESTINATION project/lib
+        PUBLIC_HEADER DESTINATION project/include/demo
+       )
+
+find_package(Python ${HATCH_CPP_TEST_PROJECT_CMAKE_C_ABI_PYTHON_VERSION} EXACT REQUIRED COMPONENTS Interpreter Development.Module)
+python_add_library(extension MODULE WITH_SOABI cpp/extension.c)
+target_link_libraries(extension PRIVATE demo)
+if(APPLE)
+    set_target_properties(extension PROPERTIES INSTALL_RPATH "@loader_path/lib")
+elseif(UNIX)
+    set_target_properties(extension PROPERTIES INSTALL_RPATH "\$ORIGIN/lib")
+endif()
+install(TARGETS extension
+        LIBRARY DESTINATION project
+        RUNTIME DESTINATION project
+       )

hatch_cpp/tests/test_project_cmake_c_abi/cpp/demo.c

@@ -0,0 +1,5 @@
+#include "demo/demo.h"
+
+int demo_abi_version(void) { return DEMO_ABI_VERSION; }
+
+int demo_answer(void) { return 42; }

hatch_cpp/tests/test_project_cmake_c_abi/cpp/extension.c

@@ -0,0 +1,11 @@
+#include <Python.h>
+
+#include "demo/demo.h"
+
+static PyObject *answer(PyObject *self, PyObject *args) { return PyLong_FromLong(demo_answer()); }
+
+static PyMethodDef methods[] = {{"answer", answer, METH_NOARGS, NULL}, {NULL, NULL, 0, NULL}};
+
+static struct PyModuleDef module = {PyModuleDef_HEAD_INIT, "extension", NULL, -1, methods};
+
+PyMODINIT_FUNC PyInit_extension(void) { return PyModule_Create(&module); }

hatch_cpp/tests/test_project_cmake_c_abi/cpp/include/demo/demo.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#define DEMO_ABI_VERSION 1
+
+#if defined(_WIN32) && defined(DEMO_BUILD)
+#define DEMO_API __declspec(dllexport)
+#elif defined(_WIN32)
+#define DEMO_API __declspec(dllimport)
+#else
+#define DEMO_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DEMO_API int demo_abi_version(void);
+DEMO_API int demo_answer(void);
+
+#ifdef __cplusplus
+}
+#endif

hatch_cpp/tests/test_project_cmake_c_abi/project/__init__.py

@@ -0,0 +1,5 @@
+import os
+import sys
+
+if sys.platform == "win32":
+    os.add_dll_directory(os.path.join(os.path.dirname(__file__), "lib"))

hatch_cpp/tests/test_project_cmake_c_abi/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling>=1.20"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-cpp-test-project-cmake-c-abi"
+description = "CMake-built C ABI library validated by hatch-cpp"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+    "hatchling>=1.20",
+    "hatch-cpp",
+]
+
+[tool.hatch.build]
+artifacts = [
+    "project/*.pyd",
+    "project/*.so",
+    "project/include/**/*.h",
+    "project/lib/*.dll",
+    "project/lib/*.dylib",
+    "project/lib/*.json",
+    "project/lib/*.lib",
+    "project/lib/*.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
+artifact-manifest = true
+artifact-manifest-destination = "project/lib/hatch-cpp-artifacts.json"
+
+[tool.hatch.build.hooks.hatch-cpp.cmake]
+root = "CMakeLists.txt"
+include_flags = {"python_version" = true}
+
+# No path: hatch-cpp finds the one packaged libdemo.so, libdemo.dylib, or demo.dll.
+[[tool.hatch.build.hooks.hatch-cpp.artifacts]]
+name = "demo"
+expected-headers = ["project/include/demo/demo.h"]
+header-symbol-prefix = "demo_"
+expected-abi-strings = ["DEMO_ABI_VERSION 1"]

hatch_cpp/tests/test_project_pyodide/pyodide_project/extension.pyi

@@ -0,0 +1 @@
+def answer() -> int: ...

hatch_cpp/tests/test_projects.py

@@ -1,4 +1,5 @@
 import contextlib
+from importlib import import_module
 from os import listdir, remove
 from pathlib import Path
 from subprocess import check_call
@@ -14,7 +15,12 @@ class TestProject:
         [
             "test_project_basic",
             "test_project_override_classes",
-            "test_project_override_toolchain",
+            pytest.param(
+                "test_project_override_toolchain",
+                marks=pytest.mark.skipif(
+                    platform == "win32", reason="the fixture selects the gcc toolchain, whose flags clang rejects for MSVC targets"
+                ),
+            ),
             "test_project_pybind",
             "test_project_pybind_vcpkg",
             "test_project_nanobind",
@@ -60,6 +66,6 @@ class TestProject:
         # import
         here = Path(__file__).parent / project
         path.insert(0, str(here))
-        import project.extension
+        extension = import_module("project.extension")
 
-        assert project.extension.hello() == "A string"
+        assert extension.hello() == "A string"