Implement prepare_metadata_for_build_wheel PEP 517 hook (#39)

* add prepare_metadata_for_build_wheel

* do not generate wheel

* wip

* simplify

Author: czoido

src/conan_py_build/build.py

@@ -317,6 +317,7 @@ def _create_dist_info(staging_dir: Path, metadata: dict, project_dir: Path) -> P
     return dist_info_dir
 
 
+
 # PEP 517 Hooks
 
 def get_requires_for_build_wheel(config_settings: Optional[dict] = None) -> list:
@@ -333,6 +334,34 @@ def get_requires_for_build_sdist(config_settings: Optional[dict] = None) -> list
     return []
 
 
+def prepare_metadata_for_build_wheel(
+    metadata_directory: str,
+    config_settings: Optional[dict] = None,
+) -> str:
+    """
+    PEP 517 hook: Prepare wheel metadata without building the full wheel.
+
+    Creates a .dist-info directory inside metadata_directory containing only
+    METADATA. The WHEEL file is intentionally omitted: wheel tags depend on
+    Conan's VirtualBuildEnv and cannot be computed reliably at this stage.
+
+    Returns the name of the created directory.
+    """
+    metadata_dir = Path(metadata_directory)
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+
+    source_dir = Path.cwd()
+    project_metadata = _get_project_metadata(source_dir)
+    _resolve_version(project_metadata, source_dir)
+
+    name = _normalize_name(project_metadata.get("name", "unknown"))
+    version = project_metadata.get("version", "0.0.0")
+    print(f"Preparing metadata for {name} {version}...", flush=True)
+
+    dist_info_dir = _create_dist_info(metadata_dir, project_metadata, source_dir)
+    return dist_info_dir.name
+
+
 def build_wheel(
     wheel_directory: str,
     config_settings: Optional[dict] = None,
@@ -341,14 +370,12 @@ def build_wheel(
     """
     PEP 517 hook: Build a wheel from the source tree.
 
-    Note: prepare_metadata_for_build_wheel is not implemented, so
-    metadata_directory is ignored if provided.
+    When metadata_directory is provided its contents (METADATA, license files,
+    and any extra entries) are copied into the wheel unchanged. The WHEEL file
+    and RECORD are still written by distlib during wheel packaging. Wheel tags
+    are always recomputed inside VirtualBuildEnv.
     """
 
-    if metadata_directory is not None:
-        print(f"WARNING: metadata_directory provided: '{metadata_directory}' - " \
-               "backend will ignore/recreate dist-info.")
-
     wheel_dir = Path(wheel_directory)
     wheel_dir.mkdir(parents=True, exist_ok=True)
 
@@ -370,6 +397,7 @@ def build_wheel(
             version,
             project_metadata,
             config,
+            metadata_directory,
         )
 
 
@@ -426,6 +454,7 @@ def _do_build_wheel(
     version: str,
     project_metadata: dict,
     config: dict,
+    metadata_directory: Optional[str] = None,
 ) -> str:
     """Internal function that performs the actual wheel build."""
 
@@ -539,8 +568,12 @@ def _do_build_wheel(
     # Copy shared libs from Conan's runtime_deploy to the wheel layout.
     move_deploy_to_wheel(runtime_deploy_dir, staging_dir)
 
-    # Create dist-info
-    _create_dist_info(staging_dir, project_metadata, source_dir)
+    # Create dist-info (or reuse the one prepared by prepare_metadata_for_build_wheel)
+    if metadata_directory is not None:
+        src = Path(metadata_directory)  # PEP 517: metadata_directory is the .dist-info path itself
+        shutil.copytree(src, staging_dir / src.name, dirs_exist_ok=True)
+    else:
+        _create_dist_info(staging_dir, project_metadata, source_dir)
 
     # Build wheel using distlib. Apply Conan's buildenv to get cross-compile
     # wheel tags from [buildenv]

tests/test_integration.py

@@ -8,7 +8,7 @@
 
 import pytest
 
-from conan_py_build.build import build_sdist, build_wheel
+from conan_py_build.build import build_sdist, build_wheel, prepare_metadata_for_build_wheel
 
 
 _DEFAULT_PYPROJECT = """\
@@ -137,6 +137,24 @@ def test_sdist_pkg_info_and_wheel_metadata_identical(integration_project):
     assert pkg_info.strip() == wheel_metadata.strip(), "PKG-INFO and METADATA must be the same core metadata"
 
 
+def test_prepare_metadata_matches_wheel_metadata(integration_project):
+    """Integration: METADATA from prepare_metadata_for_build_wheel matches the METADATA in the final wheel."""
+    meta_dir = integration_project.work_dir / "meta"
+    meta_dir.mkdir()
+    dist_info_name = prepare_metadata_for_build_wheel(str(meta_dir))
+    prepared = (meta_dir / dist_info_name / "METADATA").read_text(encoding="utf-8")
+
+    wheel_dir = integration_project.work_dir / "dist"
+    wheel_dir.mkdir()
+    wheel_name = build_wheel(str(wheel_dir))
+
+    with zipfile.ZipFile(wheel_dir / wheel_name) as zf:
+        (entry,) = [n for n in zf.namelist() if n.endswith(".dist-info/METADATA")]
+        built = zf.read(entry).decode("utf-8")
+
+    assert prepared.strip() == built.strip()
+
+
 def test_build_wheel_integration(integration_project, capfd):
     """Integration: build_wheel on a real project."""
     wheel_dir = integration_project.work_dir / "wheelhouse"
@@ -148,6 +166,29 @@ def test_build_wheel_integration(integration_project, capfd):
     assert "source_called" in err
 
 
+def test_build_wheel_uses_metadata_directory(integration_project):
+    """build_wheel copies pre-built dist-info when metadata_directory is provided (PEP 517 contract)."""
+    meta_dir = integration_project.work_dir / "meta"
+    meta_dir.mkdir()
+    dist_info_name = prepare_metadata_for_build_wheel(str(meta_dir))
+    dist_info_path = meta_dir / dist_info_name
+    # Simulate a frontend adding an extra entry to the pre-built dist-info
+    (dist_info_path / "extra.txt").write_text("sentinel")
+
+    wheel_dir = integration_project.work_dir / "dist"
+    wheel_dir.mkdir()
+    # Pass the .dist-info path directly (spec-correct form)
+    wheel_name = build_wheel(str(wheel_dir), metadata_directory=str(dist_info_path))
+
+    with zipfile.ZipFile(wheel_dir / wheel_name) as zf:
+        names = zf.namelist()
+        assert any(n.endswith(".dist-info/extra.txt") for n in names), \
+            "Extra file from metadata_directory must be preserved in the wheel"
+        (entry,) = [n for n in names if n.endswith(".dist-info/METADATA")]
+        prepared = (dist_info_path / "METADATA").read_text(encoding="utf-8")
+        assert prepared.strip() == zf.read(entry).decode("utf-8").strip()
+
+
 def test_build_wheel_with_profile_autodetect(integration_project, monkeypatch):
     """With CONAN_PY_BUILD_PROFILE_AUTODETECT=1 a local profile is created; by default Conan default is used."""
     profile_path = integration_project.project_dir / "conan-py-build.profile"
@@ -207,6 +248,7 @@ def test_build_sdist_version_file(tmp_path, monkeypatch):
     assert build_sdist(str(sdist_dir)) == "file-pkg-2.3.4.tar.gz"
 
 
+
 def test_build_sdist_version_scm(tmp_path, monkeypatch):
     """Integration: build_sdist resolves dynamic version from setuptools_scm (git tag)."""
     proj = tmp_path / "proj"

tests/test_unit.py

@@ -24,6 +24,7 @@
     _copy_license_files_from_paths,
     _validate_version_config,
     _get_version_from_scm,
+    prepare_metadata_for_build_wheel,
 )
 
 
@@ -280,6 +281,7 @@ def test_create_dist_info_includes_license_file_and_metadata(tmp_path):
     assert "License-File: LICENSE" in meta_content
 
 
+
 def test_build_wheel_with_tags_produces_whl(tmp_path):
     wheel_dir = tmp_path / "dist"
     wheel_dir.mkdir(parents=True)
@@ -317,3 +319,60 @@ def test_validate_version_config_invalid_provider_raises(tmp_path):
 """, encoding="utf-8")
     with pytest.raises(RuntimeError, match="must be 'setuptools_scm'"):
         _validate_version_config(tmp_path)
+
+
+@pytest.fixture
+def prepared_dist_info(tmp_path, monkeypatch):
+    """Run prepare_metadata_for_build_wheel on a minimal project; return the dist-info Path."""
+    make_pyproject_minimal(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    name = prepare_metadata_for_build_wheel(str(tmp_path / "meta"))
+    return tmp_path / "meta" / name
+
+
+def test_prepare_metadata_returns_dist_info_name(tmp_path, monkeypatch):
+    """Returns the .dist-info directory name with normalised package name and version."""
+    make_pyproject_minimal(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    assert prepare_metadata_for_build_wheel(str(tmp_path / "meta")) == "test_pkg-1.2.3.dist-info"
+
+
+def test_prepare_metadata_metadata_content(prepared_dist_info):
+    """METADATA contains the Name and Version headers from pyproject.toml."""
+    content = (prepared_dist_info / "METADATA").read_text(encoding="utf-8")
+    assert "Name: test-pkg" in content
+    assert "Version: 1.2.3" in content
+
+
+def test_prepare_metadata_no_wheel_file(prepared_dist_info):
+    """WHEEL file is not written: tags depend on VirtualBuildEnv and cannot be computed here."""
+    assert not (prepared_dist_info / "WHEEL").exists()
+
+
+def test_prepare_metadata_dynamic_version_from_file(tmp_path, monkeypatch):
+    """Dynamic version resolved from [tool.conan-py-build.version].file is used in the directory name."""
+    make_pyproject_with_tool_config(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    name = prepare_metadata_for_build_wheel(str(tmp_path / "meta"))
+    assert name == "myadder_pybind11-0.5.0.dist-info"
+    assert "Version: 0.5.0" in (tmp_path / "meta" / name / "METADATA").read_text(encoding="utf-8")
+
+
+def test_prepare_metadata_with_license_file(tmp_path, monkeypatch):
+    """License file declared in pyproject.toml is copied into .dist-info/licenses/."""
+    (tmp_path / "pyproject.toml").write_text("""\
+[project]
+name = "licensed-pkg"
+version = "0.9.0"
+description = "Test"
+license-files = ["LICENSE"]
+
+[build-system]
+requires = ["conan-py-build"]
+build-backend = "conan_py_build.build"
+""", encoding="utf-8")
+    (tmp_path / "LICENSE").write_text("MIT", encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    dist_info = tmp_path / "meta" / prepare_metadata_for_build_wheel(str(tmp_path / "meta"))
+    assert (dist_info / "licenses" / "LICENSE").read_text() == "MIT"
+    assert "License-File: LICENSE" in (dist_info / "METADATA").read_text(encoding="utf-8")