Cleanup API Layers

Author: Behemyth

README.md

@@ -5,6 +5,13 @@ A transparent Python management solution for C++ dependencies and building.
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.md)
 [![PyPI version](https://img.shields.io/pypi/v/cppython.svg)](https://pypi.org/project/cppython/)
 
+## Goals
+
+1. **CLI** — Provide imperative commands (`build`, `test`, `bench`, `run`, `install`) for managing C++ projects within a Python ecosystem.
+2. **Plugin Architecture** — Support pluggable generators (CMake, Meson) and providers (Conan, vcpkg) so users can mix and match toolchains.
+3. **PEP 517 Build Backend** — Act as a transparent build backend that delegates to scikit-build-core or meson-python after ensuring C++ dependencies are in place.
+4. **Package Manager Integration** — Integrate with Python package managers so that `<manager> install` seamlessly handles C++ dependency installation alongside Python dependencies.
+
 ## Features
 
 ## Setup

cppython/build/backend.py

@@ -8,8 +8,10 @@
 import logging
 import tomllib
 from pathlib import Path
+from types import ModuleType
 from typing import Any
 
+import mesonpy
 from scikit_build_core import build as skbuild
 
 from cppython.build.prepare import BuildPreparationResult, prepare_build
@@ -40,10 +42,21 @@ def _is_meson_project() -> bool:
             return True
 
     # Fallback: check for meson.build file
-    if (source_dir / 'meson.build').exists():
-        return True
+    return (source_dir / 'meson.build').exists()
 
-    return False
+
+def _get_backend(is_meson: bool) -> ModuleType:
+    """Get the appropriate backend module.
+
+    Args:
+        is_meson: Whether to use meson-python instead of scikit-build-core
+
+    Returns:
+        The backend module (mesonpy or scikit_build_core.build)
+    """
+    if is_meson:
+        return mesonpy
+    return skbuild
 
 
 def _inject_cmake_toolchain(config_settings: dict[str, Any] | None, toolchain_file: Path | None) -> dict[str, Any]:
@@ -171,185 +184,63 @@ def _is_meson_build(result: BuildPreparationResult) -> bool:
 # PEP 517 Hooks - dispatching to the appropriate backend after preparation
 
 
-def get_requires_for_build_wheel(
-    config_settings: dict[str, Any] | None = None,
-) -> list[str]:
-    """Get additional requirements for building a wheel.
-
-    Args:
-        config_settings: Build configuration settings
-
-    Returns:
-        List of additional requirements
-    """
-    if _is_meson_project():
-        import mesonpy
-
-        return mesonpy.get_requires_for_build_wheel(config_settings)
-    return skbuild.get_requires_for_build_wheel(config_settings)
-
-
-def get_requires_for_build_sdist(
-    config_settings: dict[str, Any] | None = None,
-) -> list[str]:
-    """Get additional requirements for building an sdist.
-
-    Args:
-        config_settings: Build configuration settings
-
-    Returns:
-        List of additional requirements
-    """
-    if _is_meson_project():
-        import mesonpy
+def get_requires_for_build_wheel(config_settings: dict[str, Any] | None = None) -> list[str]:
+    """Get additional requirements for building a wheel."""
+    return _get_backend(_is_meson_project()).get_requires_for_build_wheel(config_settings)
 
-        return mesonpy.get_requires_for_build_sdist(config_settings)
-    return skbuild.get_requires_for_build_sdist(config_settings)
 
+def get_requires_for_build_sdist(config_settings: dict[str, Any] | None = None) -> list[str]:
+    """Get additional requirements for building an sdist."""
+    return _get_backend(_is_meson_project()).get_requires_for_build_sdist(config_settings)
 
-def get_requires_for_build_editable(
-    config_settings: dict[str, Any] | None = None,
-) -> list[str]:
-    """Get additional requirements for building an editable install.
 
-    Args:
-        config_settings: Build configuration settings
-
-    Returns:
-        List of additional requirements
-    """
-    if _is_meson_project():
-        import mesonpy
-
-        return mesonpy.get_requires_for_build_editable(config_settings)
-    return skbuild.get_requires_for_build_editable(config_settings)
+def get_requires_for_build_editable(config_settings: dict[str, Any] | None = None) -> list[str]:
+    """Get additional requirements for building an editable install."""
+    return _get_backend(_is_meson_project()).get_requires_for_build_editable(config_settings)
 
 
 def build_wheel(
     wheel_directory: str,
     config_settings: dict[str, Any] | None = None,
     metadata_directory: str | None = None,
 ) -> str:
-    """Build a wheel from the source distribution.
-
-    This runs CPPython's provider workflow first to ensure C++ dependencies
-    are installed, then delegates to the appropriate build backend
-    (scikit-build-core for CMake, meson-python for Meson).
-
-    Args:
-        wheel_directory: Directory to place the built wheel
-        config_settings: Build configuration settings
-        metadata_directory: Directory containing wheel metadata
-
-    Returns:
-        The basename of the built wheel
-    """
+    """Build a wheel, running CPPython preparation first."""
     logger.info('CPPython: Starting wheel build')
-
-    # Prepare CPPython and get updated settings
     result, settings = _prepare_and_get_result(config_settings)
-
-    # Delegate to the appropriate backend
-    if _is_meson_build(result):
-        import mesonpy
-
-        return mesonpy.build_wheel(wheel_directory, settings, metadata_directory)
-
-    return skbuild.build_wheel(wheel_directory, settings, metadata_directory)
+    return _get_backend(_is_meson_build(result)).build_wheel(wheel_directory, settings, metadata_directory)
 
 
 def build_sdist(
     sdist_directory: str,
     config_settings: dict[str, Any] | None = None,
 ) -> str:
-    """Build a source distribution.
-
-    For sdist, we don't run the full CPPython workflow since the C++ dependencies
-    should be resolved at wheel build time, not sdist creation time.
-
-    Args:
-        sdist_directory: Directory to place the built sdist
-        config_settings: Build configuration settings
-
-    Returns:
-        The basename of the built sdist
-    """
+    """Build a source distribution (no CPPython workflow needed)."""
     logger.info('CPPython: Starting sdist build')
-
-    # Delegate to the appropriate backend
-    if _is_meson_project():
-        import mesonpy
-
-        return mesonpy.build_sdist(sdist_directory, config_settings)
-    return skbuild.build_sdist(sdist_directory, config_settings)
+    return _get_backend(_is_meson_project()).build_sdist(sdist_directory, config_settings)
 
 
 def build_editable(
     wheel_directory: str,
     config_settings: dict[str, Any] | None = None,
     metadata_directory: str | None = None,
 ) -> str:
-    """Build an editable wheel.
-
-    This runs CPPython's provider workflow first, similar to build_wheel.
-
-    Args:
-        wheel_directory: Directory to place the built wheel
-        config_settings: Build configuration settings
-        metadata_directory: Directory containing wheel metadata
-
-    Returns:
-        The basename of the built wheel
-    """
+    """Build an editable wheel, running CPPython preparation first."""
     logger.info('CPPython: Starting editable build')
-
-    # Prepare CPPython and get updated settings
     result, settings = _prepare_and_get_result(config_settings)
-
-    # Delegate to the appropriate backend
-    if _is_meson_build(result):
-        import mesonpy
-
-        return mesonpy.build_editable(wheel_directory, settings, metadata_directory)
-
-    return skbuild.build_editable(wheel_directory, settings, metadata_directory)
+    return _get_backend(_is_meson_build(result)).build_editable(wheel_directory, settings, metadata_directory)
 
 
 def prepare_metadata_for_build_wheel(
     metadata_directory: str,
     config_settings: dict[str, Any] | None = None,
 ) -> str:
-    """Prepare metadata for wheel build.
-
-    Args:
-        metadata_directory: Directory to place the metadata
-        config_settings: Build configuration settings
-
-    Returns:
-        The basename of the metadata directory
-    """
-    if _is_meson_project():
-        import mesonpy
-
-        return mesonpy.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
-    return skbuild.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
+    """Prepare metadata for wheel build."""
+    return _get_backend(_is_meson_project()).prepare_metadata_for_build_wheel(metadata_directory, config_settings)
 
 
 def prepare_metadata_for_build_editable(
     metadata_directory: str,
     config_settings: dict[str, Any] | None = None,
 ) -> str:
-    """Prepare metadata for editable build.
-
-    Args:
-        metadata_directory: Directory to place the metadata
-        config_settings: Build configuration settings
-
-    Returns:
-        The basename of the metadata directory
-    """
-    if _is_meson_project():
-        import mesonpy
-
-        return mesonpy.prepare_metadata_for_build_editable(metadata_directory, config_settings)
-    return skbuild.prepare_metadata_for_build_editable(metadata_directory, config_settings)
+    """Prepare metadata for editable build."""
+    return _get_backend(_is_meson_project()).prepare_metadata_for_build_editable(metadata_directory, config_settings)

cppython/build/prepare.py

@@ -11,8 +11,10 @@
 from pathlib import Path
 from typing import Any
 
-from cppython.core.schema import Interface, ProjectConfiguration, SyncData
+from cppython.core.interface import NoOpInterface
+from cppython.core.schema import ProjectConfiguration, SyncData
 from cppython.project import Project
+from cppython.utility.exception import InstallationVerificationError
 
 
 @dataclass
@@ -27,17 +29,8 @@ class BuildPreparationResult:
     sync_data: SyncData | None = None
 
 
-class BuildInterface(Interface):
-    """Minimal interface implementation for build backend usage."""
-
-    def write_pyproject(self) -> None:
-        """No-op for build backend - we don't modify pyproject.toml during builds."""
-
-    def write_configuration(self) -> None:
-        """No-op for build backend - we don't modify configuration during builds."""
-
-    def write_user_configuration(self) -> None:
-        """No-op for build backend - we don't modify user configuration during builds."""
+BuildInterface = NoOpInterface
+"""Interface implementation for the build backend (no-op write-backs)."""
 
 
 class BuildPreparation:
@@ -68,32 +61,18 @@ def _load_pyproject(self) -> dict[str, Any]:
         with open(pyproject_path, 'rb') as f:
             return tomllib.load(f)
 
-    def _get_sync_data(self, project: Project) -> SyncData | None:
-        """Extract sync data from the project's provider for the active generator.
-
-        Args:
-            project: The initialized CPPython project
-
-        Returns:
-            The sync data from the provider, or None if not available
-        """
-        if not project.enabled:
-            return None
-
-        # Access the internal data to get sync information
-        data = project._data  # noqa: SLF001
-
-        # Get sync data from provider for the generator
-        return data.plugins.provider.sync_data(data.plugins.generator)
-
     def prepare(self) -> BuildPreparationResult:
         """Run CPPython preparation and return the build preparation result.
 
-        This runs the provider workflow (download tools, sync, install)
-        and extracts the sync data for injection into the build backend.
+        Syncs provider config and verifies that C++ dependencies have been
+        installed by a prior ``install()`` call. Does **not** install
+        dependencies itself — the build backend is not responsible for that.
 
         Returns:
             BuildPreparationResult containing sync data for the active generator
+
+        Raises:
+            InstallationVerificationError: If provider artifacts are missing
         """
         self.logger.info('CPPython: Preparing build environment')
 
@@ -124,12 +103,16 @@ def prepare(self) -> BuildPreparationResult:
             self.logger.info('CPPython: Project not enabled, skipping preparation')
             return BuildPreparationResult()
 
-        # Run the install workflow to ensure dependencies are ready
-        self.logger.info('CPPython: Installing C++ dependencies')
-        project.install()
+        # Sync and verify — does NOT install dependencies
+        self.logger.info('CPPython: Verifying C++ dependencies are installed')
 
-        # Extract sync data
-        sync_data = self._get_sync_data(project)
+        try:
+            sync_data = project.prepare_build()
+        except InstallationVerificationError:
+            self.logger.error(
+                "CPPython: C++ dependencies not installed. Run 'cppython install' or 'pdm install' before building."
+            )
+            raise
 
         if sync_data:
             self.logger.info('CPPython: Sync data obtained from provider: %s', type(sync_data).__name__)