hatch-cpp 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

hatch_cpp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.2"
+__version__ = "0.3.1"
 
 from .config import *
 from .hooks import *

hatch_cpp/config.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from logging import getLogger
 from os import system as system_call
 from pathlib import Path
 from typing import List, Optional
 
+from pkn import getSimpleLogger
 from pydantic import BaseModel, Field, model_validator
 
 from .toolchains import BuildType, HatchCppCmakeConfiguration, HatchCppLibrary, HatchCppPlatform, HatchCppVcpkgConfiguration, Toolchain
@@ -15,13 +15,14 @@ __all__ = (
 )
 
 
-_log = getLogger(__name__)
+log = getSimpleLogger("hatch_cpp")
 
 
 class HatchCppBuildConfig(BaseModel):
     """Build config values for Hatch C++ Builder."""
 
     verbose: Optional[bool] = Field(default=False)
+    skip: Optional[bool] = Field(default=False)
     name: Optional[str] = Field(default=None)
     libraries: List[HatchCppLibrary] = Field(default_factory=list)
     cmake: Optional[HatchCppCmakeConfiguration] = Field(default=None)
@@ -76,7 +77,7 @@ class HatchCppBuildPlan(HatchCppBuildConfig):
 
         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.")
+                log.warning("vcpkg toolchain is active; ensure that your compiler is configured to use vcpkg includes and libs.")
 
             for library in self.libraries:
                 compile_flags = self.platform.get_compile_flags(library, self.build_type)

hatch_cpp/plugin.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from logging import getLogger
-from os import getenv
 from pathlib import Path
 from platform import machine as platform_machine
 from sys import platform as sys_platform, version_info
@@ -10,7 +8,7 @@ from typing import Any
 from hatch_build import parse_extra_args_model
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
 
-from .config import HatchCppBuildConfig, HatchCppBuildPlan
+from .config import HatchCppBuildConfig, HatchCppBuildPlan, log
 from .utils import import_string
 
 __all__ = ("HatchCppBuildHook",)
@@ -20,7 +18,7 @@ class HatchCppBuildHook(BuildHookInterface[HatchCppBuildConfig]):
     """The hatch-cpp build hook."""
 
     PLUGIN_NAME = "hatch-cpp"
-    _logger = getLogger(__name__)
+    _logger = log
 
     def initialize(self, version: str, build_data: dict[str, Any]) -> None:
         """Initialize the plugin."""
@@ -35,12 +33,6 @@ class HatchCppBuildHook(BuildHookInterface[HatchCppBuildConfig]):
             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 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
 
@@ -60,10 +52,14 @@ class HatchCppBuildHook(BuildHookInterface[HatchCppBuildConfig]):
         build_plan.generate()
 
         # Log commands if in verbose mode
-        if config.verbose:
+        if build_plan.verbose:
             for command in build_plan.commands:
                 self._logger.warning(command)
 
+        if build_plan.skip:
+            self._logger.warning("Skipping build")
+            return
+
         # Execute build plan
         build_plan.execute()
 
@@ -114,4 +110,4 @@ class HatchCppBuildHook(BuildHookInterface[HatchCppBuildConfig]):
                     build_data["force_include"][str(path)] = str(path)
 
         for path in build_data["force_include"]:
-            self._logger.warning(f"Force include: {path}")
+            self._logger.info(f"Force include: {path}")

hatch_cpp/tests/test_platform_specific.py

@@ -0,0 +1,456 @@
+"""Tests for platform-specific library configuration fields."""
+
+from hatch_cpp import HatchCppLibrary, HatchCppPlatform
+
+
+class TestPlatformSpecificFields:
+    """Test suite for platform-specific field handling in HatchCppLibrary."""
+
+    def test_effective_include_dirs(self):
+        """Test that include_dirs are properly merged with platform-specific dirs."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            include_dirs=["common/include"],
+            include_dirs_linux=["linux/include"],
+            include_dirs_darwin=["darwin/include"],
+            include_dirs_win32=["win32/include"],
+        )
+
+        linux_dirs = library.get_effective_include_dirs("linux")
+        assert "common/include" in linux_dirs
+        assert "linux/include" in linux_dirs
+        assert "darwin/include" not in linux_dirs
+        assert "win32/include" not in linux_dirs
+
+        darwin_dirs = library.get_effective_include_dirs("darwin")
+        assert "common/include" in darwin_dirs
+        assert "darwin/include" in darwin_dirs
+        assert "linux/include" not in darwin_dirs
+
+        win32_dirs = library.get_effective_include_dirs("win32")
+        assert "common/include" in win32_dirs
+        assert "win32/include" in win32_dirs
+        assert "linux/include" not in win32_dirs
+
+    def test_effective_library_dirs(self):
+        """Test that library_dirs are properly merged with platform-specific dirs."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            library_dirs=["common/lib"],
+            library_dirs_linux=["linux/lib"],
+            library_dirs_darwin=["darwin/lib"],
+            library_dirs_win32=["win32/lib"],
+        )
+
+        linux_dirs = library.get_effective_library_dirs("linux")
+        assert "common/lib" in linux_dirs
+        assert "linux/lib" in linux_dirs
+        assert "darwin/lib" not in linux_dirs
+
+        darwin_dirs = library.get_effective_library_dirs("darwin")
+        assert "common/lib" in darwin_dirs
+        assert "darwin/lib" in darwin_dirs
+
+        win32_dirs = library.get_effective_library_dirs("win32")
+        assert "common/lib" in win32_dirs
+        assert "win32/lib" in win32_dirs
+
+    def test_effective_libraries(self):
+        """Test that libraries are properly merged with platform-specific libraries."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            libraries=["common"],
+            libraries_linux=["pthread", "dl"],
+            libraries_darwin=["objc"],
+            libraries_win32=["kernel32", "user32"],
+        )
+
+        linux_libs = library.get_effective_libraries("linux")
+        assert "common" in linux_libs
+        assert "pthread" in linux_libs
+        assert "dl" in linux_libs
+        assert "objc" not in linux_libs
+
+        darwin_libs = library.get_effective_libraries("darwin")
+        assert "common" in darwin_libs
+        assert "objc" in darwin_libs
+        assert "pthread" not in darwin_libs
+
+        win32_libs = library.get_effective_libraries("win32")
+        assert "common" in win32_libs
+        assert "kernel32" in win32_libs
+        assert "user32" in win32_libs
+        assert "pthread" not in win32_libs
+
+    def test_effective_compile_args(self):
+        """Test that extra_compile_args are properly merged with platform-specific args."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            extra_compile_args=["-O2"],
+            extra_compile_args_linux=["-march=native"],
+            extra_compile_args_darwin=["-mmacosx-version-min=11"],
+            extra_compile_args_win32=["/O2"],
+        )
+
+        linux_args = library.get_effective_compile_args("linux")
+        assert "-O2" in linux_args
+        assert "-march=native" in linux_args
+        assert "-mmacosx-version-min=11" not in linux_args
+
+        darwin_args = library.get_effective_compile_args("darwin")
+        assert "-O2" in darwin_args
+        assert "-mmacosx-version-min=11" in darwin_args
+
+        win32_args = library.get_effective_compile_args("win32")
+        assert "-O2" in win32_args
+        assert "/O2" in win32_args
+
+    def test_effective_link_args(self):
+        """Test that extra_link_args are properly merged with platform-specific args."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            extra_link_args=["-shared"],
+            extra_link_args_linux=["-Wl,-rpath,$ORIGIN/lib"],
+            extra_link_args_darwin=["-Wl,-rpath,@loader_path/lib"],
+            extra_link_args_win32=["/NODEFAULTLIB"],
+        )
+
+        linux_args = library.get_effective_link_args("linux")
+        assert "-shared" in linux_args
+        assert "-Wl,-rpath,$ORIGIN/lib" in linux_args
+        assert "-Wl,-rpath,@loader_path/lib" not in linux_args
+
+        darwin_args = library.get_effective_link_args("darwin")
+        assert "-shared" in darwin_args
+        assert "-Wl,-rpath,@loader_path/lib" in darwin_args
+
+        win32_args = library.get_effective_link_args("win32")
+        assert "-shared" in win32_args
+        assert "/NODEFAULTLIB" in win32_args
+
+    def test_effective_extra_objects(self):
+        """Test that extra_objects are properly merged with platform-specific objects."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            extra_objects=["common.o"],
+            extra_objects_linux=["linux.o"],
+            extra_objects_darwin=["darwin.o"],
+            extra_objects_win32=["win32.obj"],
+        )
+
+        linux_objs = library.get_effective_extra_objects("linux")
+        assert "common.o" in linux_objs
+        assert "linux.o" in linux_objs
+        assert "darwin.o" not in linux_objs
+
+        darwin_objs = library.get_effective_extra_objects("darwin")
+        assert "common.o" in darwin_objs
+        assert "darwin.o" in darwin_objs
+
+        win32_objs = library.get_effective_extra_objects("win32")
+        assert "common.o" in win32_objs
+        assert "win32.obj" in win32_objs
+
+    def test_effective_define_macros(self):
+        """Test that define_macros are properly merged with platform-specific macros."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            define_macros=["COMMON=1"],
+            define_macros_linux=["LINUX=1", "_GNU_SOURCE"],
+            define_macros_darwin=["DARWIN=1", "__APPLE__"],
+            define_macros_win32=["WIN32=1", "_WINDOWS"],
+        )
+
+        linux_macros = library.get_effective_define_macros("linux")
+        assert "COMMON=1" in linux_macros
+        assert "LINUX=1" in linux_macros
+        assert "_GNU_SOURCE" in linux_macros
+        assert "DARWIN=1" not in linux_macros
+
+        darwin_macros = library.get_effective_define_macros("darwin")
+        assert "COMMON=1" in darwin_macros
+        assert "DARWIN=1" in darwin_macros
+        assert "__APPLE__" in darwin_macros
+
+        win32_macros = library.get_effective_define_macros("win32")
+        assert "COMMON=1" in win32_macros
+        assert "WIN32=1" in win32_macros
+        assert "_WINDOWS" in win32_macros
+
+    def test_effective_undef_macros(self):
+        """Test that undef_macros are properly merged with platform-specific macros."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            undef_macros=["COMMON_UNDEF"],
+            undef_macros_linux=["LINUX_UNDEF"],
+            undef_macros_darwin=["DARWIN_UNDEF"],
+            undef_macros_win32=["WIN32_UNDEF"],
+        )
+
+        linux_macros = library.get_effective_undef_macros("linux")
+        assert "COMMON_UNDEF" in linux_macros
+        assert "LINUX_UNDEF" in linux_macros
+        assert "DARWIN_UNDEF" not in linux_macros
+
+        darwin_macros = library.get_effective_undef_macros("darwin")
+        assert "COMMON_UNDEF" in darwin_macros
+        assert "DARWIN_UNDEF" in darwin_macros
+
+        win32_macros = library.get_effective_undef_macros("win32")
+        assert "COMMON_UNDEF" in win32_macros
+        assert "WIN32_UNDEF" in win32_macros
+
+    def test_empty_platform_specific_fields(self):
+        """Test that empty platform-specific fields don't cause issues."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            include_dirs=["common/include"],
+            # No platform-specific fields set
+        )
+
+        linux_dirs = library.get_effective_include_dirs("linux")
+        assert linux_dirs == ["common/include"]
+
+        darwin_dirs = library.get_effective_include_dirs("darwin")
+        assert darwin_dirs == ["common/include"]
+
+        win32_dirs = library.get_effective_include_dirs("win32")
+        assert win32_dirs == ["common/include"]
+
+    def test_only_platform_specific_fields(self):
+        """Test that only platform-specific fields work without common fields."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            # No common include_dirs
+            include_dirs_linux=["linux/include"],
+            include_dirs_darwin=["darwin/include"],
+        )
+
+        linux_dirs = library.get_effective_include_dirs("linux")
+        assert linux_dirs == ["linux/include"]
+
+        darwin_dirs = library.get_effective_include_dirs("darwin")
+        assert darwin_dirs == ["darwin/include"]
+
+        win32_dirs = library.get_effective_include_dirs("win32")
+        assert win32_dirs == []
+
+    def test_alias_hyphenated_names(self):
+        """Test that hyphenated field names work as aliases."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            **{
+                "include-dirs": ["common/include"],
+                "include-dirs-linux": ["linux/include"],
+                "library-dirs-darwin": ["darwin/lib"],
+                "extra-compile-args-win32": ["/O2"],
+                "extra-link-args-linux": ["-Wl,-rpath,$ORIGIN"],
+                "define-macros-darwin": ["DARWIN=1"],
+                "undef-macros-win32": ["NDEBUG"],
+            },
+        )
+
+        assert library.include_dirs == ["common/include"]
+        assert library.include_dirs_linux == ["linux/include"]
+        assert library.library_dirs_darwin == ["darwin/lib"]
+        assert library.extra_compile_args_win32 == ["/O2"]
+        assert library.extra_link_args_linux == ["-Wl,-rpath,$ORIGIN"]
+        assert library.define_macros_darwin == ["DARWIN=1"]
+        assert library.undef_macros_win32 == ["NDEBUG"]
+
+
+class TestPlatformFlagsIntegration:
+    """Integration tests for platform-specific fields in compile/link flags."""
+
+    def test_compile_flags_include_platform_specific_include_dirs(self):
+        """Test that get_compile_flags includes platform-specific include dirs."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            include_dirs=["common/include"],
+            include_dirs_linux=["linux/include"],
+        )
+
+        # Create a mock linux platform
+        platform = HatchCppPlatform(cc="gcc", cxx="g++", ld="ld", platform="linux", toolchain="gcc", disable_ccache=True)
+
+        flags = platform.get_compile_flags(library)
+        assert "-Icommon/include" in flags
+        assert "-Ilinux/include" in flags
+
+    def test_compile_flags_include_platform_specific_macros(self):
+        """Test that get_compile_flags includes platform-specific define/undef macros."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            define_macros=["COMMON=1"],
+            define_macros_linux=["LINUX_SPECIFIC=1"],
+            undef_macros=["OLD_MACRO"],
+            undef_macros_linux=["LINUX_OLD"],
+        )
+
+        platform = HatchCppPlatform(cc="gcc", cxx="g++", ld="ld", platform="linux", toolchain="gcc", disable_ccache=True)
+
+        flags = platform.get_compile_flags(library)
+        assert "-DCOMMON=1" in flags
+        assert "-DLINUX_SPECIFIC=1" in flags
+        assert "-UOLD_MACRO" in flags
+        assert "-ULINUX_OLD" in flags
+
+    def test_link_flags_include_platform_specific_libraries(self):
+        """Test that get_link_flags includes platform-specific libraries."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            libraries=["common"],
+            libraries_linux=["pthread", "dl"],
+            library_dirs=["common/lib"],
+            library_dirs_linux=["linux/lib"],
+        )
+
+        platform = HatchCppPlatform(cc="gcc", cxx="g++", ld="ld", platform="linux", toolchain="gcc", disable_ccache=True)
+
+        flags = platform.get_link_flags(library)
+        assert "-lcommon" in flags
+        assert "-lpthread" in flags
+        assert "-ldl" in flags
+        assert "-Lcommon/lib" in flags
+        assert "-Llinux/lib" in flags
+
+    def test_link_flags_include_platform_specific_link_args(self):
+        """Test that get_link_flags includes platform-specific extra_link_args."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            extra_link_args=["-shared"],
+            extra_link_args_linux=["-Wl,-rpath,$ORIGIN/lib"],
+        )
+
+        platform = HatchCppPlatform(cc="gcc", cxx="g++", ld="ld", platform="linux", toolchain="gcc", disable_ccache=True)
+
+        flags = platform.get_link_flags(library)
+        assert "-shared" in flags
+        assert "-Wl,-rpath,$ORIGIN/lib" in flags
+
+    def test_darwin_platform_uses_darwin_specific_fields(self):
+        """Test that darwin platform uses darwin-specific fields."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            libraries_linux=["pthread"],
+            libraries_darwin=["objc"],
+            extra_link_args_darwin=["-Wl,-rpath,@loader_path/lib"],
+        )
+
+        platform = HatchCppPlatform(cc="clang", cxx="clang++", ld="ld", platform="darwin", toolchain="clang", disable_ccache=True)
+
+        flags = platform.get_link_flags(library)
+        assert "-lobjc" in flags
+        assert "-lpthread" not in flags
+        assert "-Wl,-rpath,@loader_path/lib" in flags
+
+    def test_win32_platform_uses_win32_specific_fields(self):
+        """Test that win32 platform uses win32-specific fields."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            libraries=["common"],
+            libraries_win32=["kernel32"],
+            library_dirs=["common/lib"],
+            library_dirs_win32=["win32/lib"],
+        )
+
+        platform = HatchCppPlatform(cc="cl", cxx="cl", ld="link", platform="win32", toolchain="msvc", disable_ccache=True)
+
+        flags = platform.get_link_flags(library)
+        assert "common.lib" in flags
+        assert "kernel32.lib" in flags
+        assert "/LIBPATH:common/lib" in flags
+        assert "/LIBPATH:win32/lib" in flags
+
+    def test_msvc_compile_flags_use_platform_specific_fields(self):
+        """Test that MSVC compile flags include platform-specific fields."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            binding="generic",
+            include_dirs=["common/include"],
+            include_dirs_win32=["win32/include"],
+            define_macros=["COMMON=1"],
+            define_macros_win32=["_WINDOWS"],
+            extra_compile_args_win32=["/W4"],
+        )
+
+        platform = HatchCppPlatform(cc="cl", cxx="cl", ld="link", platform="win32", toolchain="msvc", disable_ccache=True)
+
+        flags = platform.get_compile_flags(library)
+        assert "/Icommon/include" in flags
+        assert "/Iwin32/include" in flags
+        assert "/DCOMMON=1" in flags
+        assert "/D_WINDOWS" in flags
+        assert "/W4" in flags
+
+
+class TestPlatformFieldOrdering:
+    """Test that platform-specific fields are appended after common fields."""
+
+    def test_include_dirs_ordering(self):
+        """Test that platform-specific include dirs come after common dirs."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            include_dirs=["first", "second"],
+            include_dirs_linux=["third", "fourth"],
+        )
+
+        dirs = library.get_effective_include_dirs("linux")
+        assert dirs == ["first", "second", "third", "fourth"]
+
+    def test_libraries_ordering(self):
+        """Test that platform-specific libraries come after common libraries."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            libraries=["common1", "common2"],
+            libraries_linux=["linux1", "linux2"],
+        )
+
+        libs = library.get_effective_libraries("linux")
+        assert libs == ["common1", "common2", "linux1", "linux2"]
+
+    def test_base_list_not_mutated(self):
+        """Test that the base lists are not mutated when getting effective values."""
+        library = HatchCppLibrary(
+            name="test",
+            sources=["test.cpp"],
+            include_dirs=["common"],
+            include_dirs_linux=["linux"],
+        )
+
+        # Get effective dirs multiple times
+        dirs1 = library.get_effective_include_dirs("linux")
+        dirs2 = library.get_effective_include_dirs("linux")
+
+        # Both should be equal
+        assert dirs1 == dirs2
+
+        # Base list should not be modified
+        assert library.include_dirs == ["common"]
+        assert library.include_dirs_linux == ["linux"]

hatch_cpp/toolchains/common.py

@@ -47,15 +47,44 @@ class HatchCppLibrary(BaseModel, validate_assignment=True):
     std: Optional[str] = None
 
     include_dirs: List[str] = Field(default_factory=list, alias=AliasChoices("include_dirs", "include-dirs"))
+    include_dirs_linux: List[str] = Field(default_factory=list, alias=AliasChoices("include_dirs_linux", "include-dirs-linux"))
+    include_dirs_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("include_dirs_darwin", "include-dirs-darwin"))
+    include_dirs_win32: List[str] = Field(default_factory=list, alias=AliasChoices("include_dirs_win32", "include-dirs-win32"))
+
     library_dirs: List[str] = Field(default_factory=list, alias=AliasChoices("library_dirs", "library-dirs"))
+    library_dirs_linux: List[str] = Field(default_factory=list, alias=AliasChoices("library_dirs_linux", "library-dirs-linux"))
+    library_dirs_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("library_dirs_darwin", "library-dirs-darwin"))
+    library_dirs_win32: List[str] = Field(default_factory=list, alias=AliasChoices("library_dirs_win32", "library-dirs-win32"))
+
     libraries: List[str] = Field(default_factory=list)
+    libraries_linux: List[str] = Field(default_factory=list, alias=AliasChoices("libraries_linux", "libraries-linux"))
+    libraries_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("libraries_darwin", "libraries-darwin"))
+    libraries_win32: List[str] = Field(default_factory=list, alias=AliasChoices("libraries_win32", "libraries-win32"))
 
     extra_compile_args: List[str] = Field(default_factory=list, alias=AliasChoices("extra_compile_args", "extra-compile-args"))
+    extra_compile_args_linux: List[str] = Field(default_factory=list, alias=AliasChoices("extra_compile_args_linux", "extra-compile-args-linux"))
+    extra_compile_args_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("extra_compile_args_darwin", "extra-compile-args-darwin"))
+    extra_compile_args_win32: List[str] = Field(default_factory=list, alias=AliasChoices("extra_compile_args_win32", "extra-compile-args-win32"))
+
     extra_link_args: List[str] = Field(default_factory=list, alias=AliasChoices("extra_link_args", "extra-link-args"))
+    extra_link_args_linux: List[str] = Field(default_factory=list, alias=AliasChoices("extra_link_args_linux", "extra-link-args-linux"))
+    extra_link_args_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("extra_link_args_darwin", "extra-link-args-darwin"))
+    extra_link_args_win32: List[str] = Field(default_factory=list, alias=AliasChoices("extra_link_args_win32", "extra-link-args-win32"))
+
     extra_objects: List[str] = Field(default_factory=list, alias=AliasChoices("extra_objects", "extra-objects"))
+    extra_objects_linux: List[str] = Field(default_factory=list, alias=AliasChoices("extra_objects_linux", "extra-objects-linux"))
+    extra_objects_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("extra_objects_darwin", "extra-objects-darwin"))
+    extra_objects_win32: List[str] = Field(default_factory=list, alias=AliasChoices("extra_objects_win32", "extra-objects-win32"))
 
     define_macros: List[str] = Field(default_factory=list, alias=AliasChoices("define_macros", "define-macros"))
+    define_macros_linux: List[str] = Field(default_factory=list, alias=AliasChoices("define_macros_linux", "define-macros-linux"))
+    define_macros_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("define_macros_darwin", "define-macros-darwin"))
+    define_macros_win32: List[str] = Field(default_factory=list, alias=AliasChoices("define_macros_win32", "define-macros-win32"))
+
     undef_macros: List[str] = Field(default_factory=list, alias=AliasChoices("undef_macros", "undef-macros"))
+    undef_macros_linux: List[str] = Field(default_factory=list, alias=AliasChoices("undef_macros_linux", "undef-macros-linux"))
+    undef_macros_darwin: List[str] = Field(default_factory=list, alias=AliasChoices("undef_macros_darwin", "undef-macros-darwin"))
+    undef_macros_win32: List[str] = Field(default_factory=list, alias=AliasChoices("undef_macros_win32", "undef-macros-win32"))
 
     export_symbols: List[str] = Field(default_factory=list, alias=AliasChoices("export_symbols", "export-symbols"))
     depends: List[str] = Field(default_factory=list)
@@ -89,6 +118,94 @@ class HatchCppLibrary(BaseModel, validate_assignment=True):
             raise ValueError("Generic binding can not support Py_LIMITED_API")
         return self
 
+    def get_effective_link_args(self, platform: Platform) -> List[str]:
+        """Get link args merged with platform-specific link args."""
+        args = list(self.extra_link_args)
+        if platform == "linux":
+            args.extend(self.extra_link_args_linux)
+        elif platform == "darwin":
+            args.extend(self.extra_link_args_darwin)
+        elif platform == "win32":
+            args.extend(self.extra_link_args_win32)
+        return args
+
+    def get_effective_include_dirs(self, platform: Platform) -> List[str]:
+        """Get include dirs merged with platform-specific include dirs."""
+        dirs = list(self.include_dirs)
+        if platform == "linux":
+            dirs.extend(self.include_dirs_linux)
+        elif platform == "darwin":
+            dirs.extend(self.include_dirs_darwin)
+        elif platform == "win32":
+            dirs.extend(self.include_dirs_win32)
+        return dirs
+
+    def get_effective_library_dirs(self, platform: Platform) -> List[str]:
+        """Get library dirs merged with platform-specific library dirs."""
+        dirs = list(self.library_dirs)
+        if platform == "linux":
+            dirs.extend(self.library_dirs_linux)
+        elif platform == "darwin":
+            dirs.extend(self.library_dirs_darwin)
+        elif platform == "win32":
+            dirs.extend(self.library_dirs_win32)
+        return dirs
+
+    def get_effective_libraries(self, platform: Platform) -> List[str]:
+        """Get libraries merged with platform-specific libraries."""
+        libs = list(self.libraries)
+        if platform == "linux":
+            libs.extend(self.libraries_linux)
+        elif platform == "darwin":
+            libs.extend(self.libraries_darwin)
+        elif platform == "win32":
+            libs.extend(self.libraries_win32)
+        return libs
+
+    def get_effective_compile_args(self, platform: Platform) -> List[str]:
+        """Get compile args merged with platform-specific compile args."""
+        args = list(self.extra_compile_args)
+        if platform == "linux":
+            args.extend(self.extra_compile_args_linux)
+        elif platform == "darwin":
+            args.extend(self.extra_compile_args_darwin)
+        elif platform == "win32":
+            args.extend(self.extra_compile_args_win32)
+        return args
+
+    def get_effective_extra_objects(self, platform: Platform) -> List[str]:
+        """Get extra objects merged with platform-specific extra objects."""
+        objs = list(self.extra_objects)
+        if platform == "linux":
+            objs.extend(self.extra_objects_linux)
+        elif platform == "darwin":
+            objs.extend(self.extra_objects_darwin)
+        elif platform == "win32":
+            objs.extend(self.extra_objects_win32)
+        return objs
+
+    def get_effective_define_macros(self, platform: Platform) -> List[str]:
+        """Get define macros merged with platform-specific define macros."""
+        macros = list(self.define_macros)
+        if platform == "linux":
+            macros.extend(self.define_macros_linux)
+        elif platform == "darwin":
+            macros.extend(self.define_macros_darwin)
+        elif platform == "win32":
+            macros.extend(self.define_macros_win32)
+        return macros
+
+    def get_effective_undef_macros(self, platform: Platform) -> List[str]:
+        """Get undef macros merged with platform-specific undef macros."""
+        macros = list(self.undef_macros)
+        if platform == "linux":
+            macros.extend(self.undef_macros_linux)
+        elif platform == "darwin":
+            macros.extend(self.undef_macros_darwin)
+        elif platform == "win32":
+            macros.extend(self.undef_macros_win32)
+        return macros
+
 
 class HatchCppPlatform(BaseModel):
     cc: str
@@ -96,13 +213,13 @@ class HatchCppPlatform(BaseModel):
     ld: str
     platform: Platform
     toolchain: CompilerToolchain
+    disable_ccache: bool = False
 
     @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"])
+        CC = environ.get("CC", PlatformDefaults[sys_platform]["CC"])
+        CXX = environ.get("CXX", PlatformDefaults[sys_platform]["CXX"])
+        LD = environ.get("LD", PlatformDefaults[sys_platform]["LD"])
         if "gcc" in CC and "g++" in CXX:
             toolchain = "gcc"
         elif "clang" in CC and "clang++" in CXX:
@@ -110,26 +227,34 @@ class HatchCppPlatform(BaseModel):
         elif "cl" in CC and "cl" in CXX:
             toolchain = "msvc"
         # Fallback to platform defaults
-        elif platform == "linux":
+        elif sys_platform == "linux":
             toolchain = "gcc"
-        elif platform == "darwin":
+        elif sys_platform == "darwin":
             toolchain = "clang"
-        elif platform == "win32":
+        elif sys_platform == "win32":
             toolchain = "msvc"
         else:
             toolchain = "gcc"
 
-        # Customizations
-        if which("ccache") and not environ.get("HATCH_CPP_DISABLE_CCACHE"):
-            CC = f"ccache {CC}"
-            CXX = f"ccache {CXX}"
-
+        # TODO:
         # 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)
+        return HatchCppPlatform(cc=CC, cxx=CXX, ld=LD, platform=sys_platform, toolchain=toolchain)
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def validate_model(cls, data, handler):
+        model = handler(data)
+        if which("ccache") and not model.disable_ccache:
+            if model.toolchain in ["gcc", "clang"]:
+                if not model.cc.startswith("ccache "):
+                    model.cc = f"ccache {model.cc}"
+                if not model.cxx.startswith("ccache "):
+                    model.cxx = f"ccache {model.cxx}"
+        return model
 
     @staticmethod
     def platform_for_toolchain(toolchain: CompilerToolchain) -> HatchCppPlatform:
@@ -140,54 +265,62 @@ class HatchCppPlatform(BaseModel):
     def get_compile_flags(self, library: HatchCppLibrary, build_type: BuildType = "release") -> str:
         flags = ""
 
+        # Get effective platform-specific values
+        effective_include_dirs = library.get_effective_include_dirs(self.platform)
+        effective_compile_args = library.get_effective_compile_args(self.platform)
+        effective_define_macros = library.get_effective_define_macros(self.platform)
+        effective_undef_macros = library.get_effective_undef_macros(self.platform)
+        effective_extra_objects = library.get_effective_extra_objects(self.platform)
+        effective_link_args = library.get_effective_link_args(self.platform)
+
         # Python.h
         if library.binding != "generic":
-            library.include_dirs.append(get_path("include"))
+            effective_include_dirs.append(get_path("include"))
 
         if library.binding == "pybind11":
             import pybind11
 
-            library.include_dirs.append(pybind11.get_include())
+            effective_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())
+            effective_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")))
+            effective_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")
+            effective_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 += " " + " ".join(f"-I{d}" for d in effective_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)
+            flags += " " + " ".join(effective_compile_args)
+            flags += " " + " ".join(f"-D{macro}" for macro in effective_define_macros)
+            flags += " " + " ".join(f"-U{macro}" for macro in effective_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 += " ".join(f"-I{d}" for d in effective_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)
+            flags += " " + " ".join(effective_compile_args)
+            flags += " " + " ".join(f"-D{macro}" for macro in effective_define_macros)
+            flags += " " + " ".join(f"-U{macro}" for macro in effective_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 += " ".join(f"/I{d}" for d in effective_include_dirs)
+            flags += " " + " ".join(effective_compile_args)
+            flags += " " + " ".join(effective_link_args)
+            flags += " " + " ".join(effective_extra_objects)
+            flags += " " + " ".join(f"/D{macro}" for macro in effective_define_macros)
+            flags += " " + " ".join(f"/U{macro}" for macro in effective_undef_macros)
             flags += " /EHsc /DWIN32"
             if library.std:
                 flags += f" /std:{library.std}"
@@ -198,12 +331,17 @@ class HatchCppPlatform(BaseModel):
 
     def get_link_flags(self, library: HatchCppLibrary, build_type: BuildType = "release") -> str:
         flags = ""
+        effective_link_args = library.get_effective_link_args(self.platform)
+        effective_extra_objects = library.get_effective_extra_objects(self.platform)
+        effective_libraries = library.get_effective_libraries(self.platform)
+        effective_library_dirs = library.get_effective_library_dirs(self.platform)
+
         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 += " " + " ".join(effective_link_args)
+            flags += " " + " ".join(effective_extra_objects)
+            flags += " " + " ".join(f"-l{lib}" for lib in effective_libraries)
+            flags += " " + " ".join(f"-L{lib}" for lib in effective_library_dirs)
             flags += f" -o {library.get_qualified_name(self.platform)}"
             if self.platform == "darwin":
                 flags += " -undefined dynamic_lookup"
@@ -213,10 +351,10 @@ class HatchCppPlatform(BaseModel):
                 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 += " " + " ".join(effective_link_args)
+            flags += " " + " ".join(effective_extra_objects)
+            flags += " " + " ".join(f"-l{lib}" for lib in effective_libraries)
+            flags += " " + " ".join(f"-L{lib}" for lib in effective_library_dirs)
             flags += f" -o {library.get_qualified_name(self.platform)}"
             if self.platform == "darwin":
                 flags += " -undefined dynamic_lookup"
@@ -225,15 +363,15 @@ class HatchCppPlatform(BaseModel):
             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 += " " + " ".join(effective_link_args)
+            flags += " " + " ".join(effective_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)
+            flags += " " + " ".join(f"{lib}.lib" for lib in effective_libraries)
+            flags += " " + " ".join(f"/LIBPATH:{lib}" for lib in effective_library_dirs)
         # clean
         while flags.count("  "):
             flags = flags.replace("  ", " ")

hatch_cpp/toolchains/vcpkg.py

@@ -33,6 +33,7 @@ VcpkgPlatformDefaults = {
     ("darwin", "x86_64"): "x64-osx",
     ("darwin", "arm64"): "arm64-osx",
     ("win32", "x86_64"): "x64-windows-static-md",
+    ("win32", "AMD64"): "x64-windows-static-md",
     ("win32", "arm64"): "arm64-windows-static-md",
 }
 

{hatch_cpp-0.2.2.dist-info → hatch_cpp-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-cpp
-Version: 0.2.2
+Version: 0.3.1
 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
@@ -20,8 +20,9 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: hatch-build<0.6,>=0.4
+Requires-Dist: hatch-build<0.6,>=0.5
 Requires-Dist: hatchling
+Requires-Dist: pkn
 Requires-Dist: pydantic
 Provides-Extra: develop
 Requires-Dist: build; extra == 'develop'
@@ -32,7 +33,7 @@ Requires-Dist: hatch-build>=0.3.2; extra == 'develop'
 Requires-Dist: hatchling; extra == 'develop'
 Requires-Dist: mdformat-tables>=1; extra == 'develop'
 Requires-Dist: mdformat<1.1,>=0.7.22; extra == 'develop'
-Requires-Dist: nanobind<2.10.0; extra == 'develop'
+Requires-Dist: nanobind<2.12.0; extra == 'develop'
 Requires-Dist: pybind11; extra == 'develop'
 Requires-Dist: pytest; extra == 'develop'
 Requires-Dist: pytest-cov; extra == 'develop'
@@ -142,17 +143,89 @@ hatch-build \
     --libraries.0.include-dirs cpp,another-dir
 ```
 
-### Environment Variables
+This CLI is aware of your `pyproject.toml`-configured setup.
+To display help for this, run (note the passthrough `--`):
+
+```bash
+hatch-build -- --help
+```
 
-`hatch-cpp` will respect standard environment variables for compiler control.
+For example, for the `test_project_basic` in this project's `tests` folder:
+
+```raw
+hatch-build --hooks-only -- --help
+[sdist]
+
+[wheel]
+[2025-11-11T17:31:06-0500][p2a][WARNING]: Only dicts with str, int, float, bool, or enum values are supported - field `cmake_env_args` got value type typing.Dict[str, str]
+usage: hatch-build-extras-model [-h] [--verbose] [--name NAME] [--libraries.0.name LIBRARIES.0.NAME]
+                                [--libraries.0.sources.0 LIBRARIES.0.SOURCES.0] [--libraries.0.sources LIBRARIES.0.SOURCES]
+                                [--libraries.0.language LIBRARIES.0.LANGUAGE] [--libraries.0.binding LIBRARIES.0.BINDING]
+                                [--libraries.0.std LIBRARIES.0.STD] [--libraries.0.include-dirs.0 LIBRARIES.0.INCLUDE_DIRS.0]
+                                [--libraries.0.include-dirs LIBRARIES.0.INCLUDE_DIRS]
+                                [--libraries.0.library-dirs LIBRARIES.0.LIBRARY_DIRS]
+                                [--libraries.0.libraries LIBRARIES.0.LIBRARIES]
+                                [--libraries.0.extra-compile-args LIBRARIES.0.EXTRA_COMPILE_ARGS]
+                                [--libraries.0.extra-link-args LIBRARIES.0.EXTRA_LINK_ARGS]
+                                [--libraries.0.extra-objects LIBRARIES.0.EXTRA_OBJECTS]
+                                [--libraries.0.define-macros LIBRARIES.0.DEFINE_MACROS]
+                                [--libraries.0.undef-macros LIBRARIES.0.UNDEF_MACROS]
+                                [--libraries.0.export-symbols LIBRARIES.0.EXPORT_SYMBOLS]
+                                [--libraries.0.depends LIBRARIES.0.DEPENDS]
+                                [--libraries.0.py-limited-api LIBRARIES.0.PY_LIMITED_API] [--cmake.root CMAKE.ROOT]
+                                [--cmake.build CMAKE.BUILD] [--cmake.install CMAKE.INSTALL]
+                                [--cmake.cmake-arg-prefix CMAKE.CMAKE_ARG_PREFIX] [--cmake.cmake-args CMAKE.CMAKE_ARGS]
+                                [--cmake.include-flags CMAKE.INCLUDE_FLAGS] [--platform.cc PLATFORM.CC]
+                                [--platform.cxx PLATFORM.CXX] [--platform.ld PLATFORM.LD] [--platform.platform PLATFORM.PLATFORM]
+                                [--platform.toolchain PLATFORM.TOOLCHAIN] [--platform.disable-ccache] [--vcpkg.vcpkg VCPKG.VCPKG]
+                                [--vcpkg.vcpkg-root VCPKG.VCPKG_ROOT] [--vcpkg.vcpkg-repo VCPKG.VCPKG_REPO]
+                                [--vcpkg.vcpkg-triplet VCPKG.VCPKG_TRIPLET] [--build-type BUILD_TYPE] [--commands COMMANDS]
+
+options:
+  -h, --help            show this help message and exit
+  --verbose
+  --name NAME
+  --libraries.0.name LIBRARIES.0.NAME
+  --libraries.0.sources.0 LIBRARIES.0.SOURCES.0
+  --libraries.0.sources LIBRARIES.0.SOURCES
+  --libraries.0.language LIBRARIES.0.LANGUAGE
+  --libraries.0.binding LIBRARIES.0.BINDING
+  --libraries.0.std LIBRARIES.0.STD
+  --libraries.0.include-dirs.0 LIBRARIES.0.INCLUDE_DIRS.0
+  --libraries.0.include-dirs LIBRARIES.0.INCLUDE_DIRS
+  --libraries.0.library-dirs LIBRARIES.0.LIBRARY_DIRS
+  --libraries.0.libraries LIBRARIES.0.LIBRARIES
+  --libraries.0.extra-compile-args LIBRARIES.0.EXTRA_COMPILE_ARGS
+  --libraries.0.extra-link-args LIBRARIES.0.EXTRA_LINK_ARGS
+  --libraries.0.extra-objects LIBRARIES.0.EXTRA_OBJECTS
+  --libraries.0.define-macros LIBRARIES.0.DEFINE_MACROS
+  --libraries.0.undef-macros LIBRARIES.0.UNDEF_MACROS
+  --libraries.0.export-symbols LIBRARIES.0.EXPORT_SYMBOLS
+  --libraries.0.depends LIBRARIES.0.DEPENDS
+  --libraries.0.py-limited-api LIBRARIES.0.PY_LIMITED_API
+  --cmake.root CMAKE.ROOT
+  --cmake.build CMAKE.BUILD
+  --cmake.install CMAKE.INSTALL
+  --cmake.cmake-arg-prefix CMAKE.CMAKE_ARG_PREFIX
+  --cmake.cmake-args CMAKE.CMAKE_ARGS
+  --cmake.include-flags CMAKE.INCLUDE_FLAGS
+  --platform.cc PLATFORM.CC
+  --platform.cxx PLATFORM.CXX
+  --platform.ld PLATFORM.LD
+  --platform.platform PLATFORM.PLATFORM
+  --platform.toolchain PLATFORM.TOOLCHAIN
+  --platform.disable-ccache
+  --vcpkg.vcpkg VCPKG.VCPKG
+  --vcpkg.vcpkg-root VCPKG.VCPKG_ROOT
+  --vcpkg.vcpkg-repo VCPKG.VCPKG_REPO
+  --vcpkg.vcpkg-triplet VCPKG.VCPKG_TRIPLET
+  --build-type BUILD_TYPE
+  --commands COMMANDS
+```
+
+### Environment Variables
 
-| Name                       | Default | Description           |
-| :------------------------- | :------ | :-------------------- |
-| `CC`                       |         | C Compiler override   |
-| `CXX`                      |         | C++ Compiler override |
-| `LD`                       |         | Linker override       |
-| `HATCH_CPP_PLATFORM`       |         | Platform to build     |
-| `HATCH_CPP_DISABLE_CCACHE` |         | Disable CCache usage  |
+`hatch-cpp` will respect standard environment variables for compiler control, e.g. `CC`, `CXX`, `LD`, `CMAKE_GENERATOR`, `OSX_DEPLOYMENT_TARGET`, etc.
 
 > [!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.2.2.dist-info → hatch_cpp-0.3.1.dist-info}/RECORD

@@ -1,9 +1,10 @@
-hatch_cpp/__init__.py,sha256=K9MSlud8adPKmDzkJWwPGoEVanTCIFGjZM-UI5yKkGE,114
-hatch_cpp/config.py,sha256=8UIdlc6fHEBNgjmLZ1op3x-16BARxx4GJHPwAFQlOUw,3641
+hatch_cpp/__init__.py,sha256=NiHzyZHO9thWWlAsLinBL03KdZwgTXAKh3yDMnAIKRs,114
+hatch_cpp/config.py,sha256=LlwDBmD1nir08Y5GOl4wa29h2iJBtNRSzYMGHRVFJUo,3698
 hatch_cpp/hooks.py,sha256=SQkF5WJIgzw-8rvlTzuQvBqdP6K3fHgnh6CZOZFag50,203
-hatch_cpp/plugin.py,sha256=pywarl9lNXMMYmYa0OMT2Q3VQGvViusaa0-tZbMA1W4,4523
+hatch_cpp/plugin.py,sha256=NcIDi7c9KH-_RkPeeCgWKoH5InIjw2eECswazwvGl_c,4304
 hatch_cpp/utils.py,sha256=lxd3U3aMYsTS6DYMc1y17MR16LzgRzv92f_xh87LSg8,297
 hatch_cpp/tests/test_hatch_build.py,sha256=q2IKTFi3Pq99UsOyL84V-C9VtFUs3ZcA9UlA8lpRW54,1553
+hatch_cpp/tests/test_platform_specific.py,sha256=UaqYFoKfdxNG5p4ZlPsCJE50LB8HzzgVDRlYG03YHQM,17722
 hatch_cpp/tests/test_projects.py,sha256=vs-kHdiHM7pCqM3oGQsSryq5blRi0HyK5QFfHxlJDi8,1773
 hatch_cpp/tests/test_structs.py,sha256=cpzbPLneEbEONzXmPS1S9PL9mbhya4udc4eqTpU9w6w,2576
 hatch_cpp/tests/test_project_basic/pyproject.toml,sha256=eqM1UVpNmJWDfsuO18ZG_VOV9I4tAWgsM5Dhf49X8Nc,694
@@ -56,10 +57,10 @@ hatch_cpp/tests/test_project_pybind_vcpkg/cpp/project/basic.hpp,sha256=LZSfCfhLY
 hatch_cpp/tests/test_project_pybind_vcpkg/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hatch_cpp/toolchains/__init__.py,sha256=anza4tXKxauobWMOUrxX3sEO0qs7sp6VdLXhLae3vkY,64
 hatch_cpp/toolchains/cmake.py,sha256=VQYYqiOu0ZEF0IBuep35Xad7jryWy04-dHYYf7c0XgY,3331
-hatch_cpp/toolchains/common.py,sha256=nBAGQ9B5a7yNgOgohUCsbnDAJACrdQ8lt5dFyb7IXMs,10076
-hatch_cpp/toolchains/vcpkg.py,sha256=fx9lo5EH3HVqg9Fnh5EO67gNsAXcza9eZz4S-Y8piJ0,2097
-hatch_cpp-0.2.2.dist-info/METADATA,sha256=df6Svm6GGIBwpNFEb1825-E4gEsbh07AAjJsrcBm62Y,5900
-hatch_cpp-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hatch_cpp-0.2.2.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
-hatch_cpp-0.2.2.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
-hatch_cpp-0.2.2.dist-info/RECORD,,
+hatch_cpp/toolchains/common.py,sha256=a8Pp6K5ykR04ZGXirQGx-xDw9xFm65O2sqrZpUlUqws,18165
+hatch_cpp/toolchains/vcpkg.py,sha256=Gwv3YNXBngpdebvRuYuUcWCzPyDbmDvy8c0K7uV4k38,2146
+hatch_cpp-0.3.1.dist-info/METADATA,sha256=elXaQLudW-BbNb0B0ZL1YCbMCr39d7GpZUaSQRB_I40,9896
+hatch_cpp-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hatch_cpp-0.3.1.dist-info/entry_points.txt,sha256=RgXfjpD4iwomJQK5n7FnPkXzb5fOnF5v3DI5hbkgVcw,30
+hatch_cpp-0.3.1.dist-info/licenses/LICENSE,sha256=FWyFTpd5xXEz50QpGDtsyIv6dgR2z_dHdoab_Nq_KMw,11452
+hatch_cpp-0.3.1.dist-info/RECORD,,

{hatch_cpp-0.2.2.dist-info → hatch_cpp-0.3.1.dist-info}/WHEEL

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