Merge pull request #7 from scikit-build/henryiii/feat/metadata2

refactor: directly specify entrypoints

Author: bennyrowland

noxfile.py

@@ -38,9 +38,7 @@ def tests(session: nox.Session) -> None:
     Run the unit and regular tests.
     """
     env = {"PIP_DISABLE_PIP_VERSION_CHECK": "1"}
-    # add hatch-fancy-pypi-readme and setuptools-scm to extra to test the
-    # dynamic metadata plugins
-    extra = []
+    extra = ["hatch-fancy-pypi-readme", "setuptools-scm"]
     # This will not work if system CMake is too old (<3.15)
     if shutil.which("cmake") is None and shutil.which("cmake3") is None:
         extra.append("cmake")

pyproject.toml

@@ -33,7 +33,6 @@ dynamic = ["version"]
 
 dependencies = [
     "exceptiongroup; python_version<'3.11'",
-    "importlib-metadata >=4.13; python_version<'3.11'",
     "importlib_resources >=1.3; python_version<'3.9'",
     "packaging >=20.9",
     "tomli >=1.1; python_version<'3.11'",
@@ -89,10 +88,6 @@ Examples = "https://github.com/scikit-build/scikit-build-core/tree/main/tests/pa
 cmake_extensions = "scikit_build_core.setuptools.extension:cmake_extensions"
 cmake_source_dir = "scikit_build_core.setuptools.extension:cmake_source_dir"
 
-[project.entry-points."scikit_build.metadata"]
-setuptools_scm = "scikit_build_core.settings.metadata:setuptools_scm_version"
-fancy_pypi_readme = "scikit_build_core.settings.metadata:fancy_pypi_readme"
-
 [tool.hatch]
 version.source = "vcs"
 build.hooks.vcs.version-file = "src/scikit_build_core/_version.py"
@@ -194,7 +189,7 @@ select = [
     "UP",          # pyupgrade
     "YTT",         # flake8-2020
 ]
-extend-ignore = ["PLR0915", "PLR0912", "PLR2004", "E501"]
+extend-ignore = ["PLR", "E501", "PT004"]
 target-version = "py37"
 typing-modules = ["scikit_build_core._compat.typing"]
 src = ["src"]

src/scikit_build_core/_compat/importlib.py

@@ -7,12 +7,7 @@
 else:
     from importlib import resources
 
-if sys.version_info < (3, 11):
-    import importlib_metadata as metadata
-else:
-    from importlib import metadata
-
-__all__ = ["metadata", "resources"]
+__all__ = ["resources"]
 
 
 def __dir__() -> list[str]:

src/scikit_build_core/metadata/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__all__: list[str] = []

src/scikit_build_core/metadata/fancy_pypi_readme.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["dynamic_metadata"]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+def dynamic_metadata(
+    pyproject_dict: dict[str, Any]
+) -> dict[str, str | dict[str, str | None]]:
+    from hatch_fancy_pypi_readme._builder import build_text
+    from hatch_fancy_pypi_readme._config import load_and_validate_config
+
+    config = load_and_validate_config(
+        pyproject_dict["tool"]["hatch"]["metadata"]["hooks"]["fancy-pypi-readme"]
+    )
+
+    return {
+        "readme": {
+            "content-type": config.content_type,
+            "text": build_text(config.fragments, config.substitutions),
+        }
+    }

src/scikit_build_core/metadata/setuptools_scm.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+__all__ = ["dynamic_metadata"]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+def dynamic_metadata(
+    pyproject_dict: dict[str, object]  # noqa: ARG001
+) -> dict[str, str | dict[str, str | None]]:
+    # this is a classic implementation, waiting for the release of
+    # vcs-versioning and an improved public interface
+    from setuptools_scm import Configuration, _get_version
+
+    config = Configuration.from_file(str(Path("pyproject.toml")))
+    version: str = _get_version(config)
+
+    return {"version": version}

src/scikit_build_core/settings/metadata.py

@@ -1,50 +1,21 @@
 from __future__ import annotations
 
-import warnings
-from pathlib import Path
+import importlib
 from typing import Any
 
 from pyproject_metadata import StandardMetadata
 
-from .._compat import importlib
 from ..settings.skbuild_model import ScikitBuildSettings
 
-__all__ = ["setuptools_scm_version", "fancy_pypi_readme", "get_standard_metadata"]
+__all__ = ["get_standard_metadata"]
 
 
 def __dir__() -> list[str]:
     return __all__
 
 
-def setuptools_scm_version(
-    _pyproject_dict: dict[str, Any]
-) -> dict[str, str | dict[str, str | None]]:
-    # this is a placeholder version of this function, waiting for the release
-    # of vcs-versioning and an improved public interface
-    from setuptools_scm import Configuration, _get_version
-
-    config = Configuration.from_file(str(Path("pyproject.toml")))
-    version: str = _get_version(config)
-
-    return {"version": version}
-
-
-def fancy_pypi_readme(
-    pyproject_dict: dict[str, Any]
-) -> dict[str, str | dict[str, str | None]]:
-    from hatch_fancy_pypi_readme._builder import build_text
-    from hatch_fancy_pypi_readme._config import load_and_validate_config
-
-    config = load_and_validate_config(
-        pyproject_dict["tool"]["hatch"]["metadata"]["hooks"]["fancy-pypi-readme"]
-    )
-
-    return {
-        "readme": {
-            "content-type": config.content_type,
-            "text": build_text(config.fragments, config.substitutions),
-        }
-    }
+def _load(mod_name: str, pyproject_dict: dict[str, Any]) -> dict[str, Any]:
+    return importlib.import_module(mod_name).dynamic_metadata(pyproject_dict)  # type: ignore[no-any-return]
 
 
 def get_standard_metadata(
@@ -53,33 +24,23 @@ def get_standard_metadata(
     metadata = StandardMetadata.from_pyproject(pyproject_dict)
 
     # handle any dynamic metadata
-    # start by collecting all the scikit-build entrypoints
-    eps: importlib.metadata.EntryPoints = importlib.metadata.entry_points(
-        group="scikit_build.metadata"
-    )
-    cached_plugins = {}
-    for field, ep_name in settings.metadata.items():
+    for field in settings.metadata:
         if field not in metadata.dynamic:
             msg = f"{field} is not in project.dynamic"
             raise KeyError(msg)
-        if ep_name not in cached_plugins:
-            try:
-                ep = eps[ep_name]
-            except KeyError:
-                warnings.warn(
-                    f"could not find requested entrypoint {ep_name} for field {field}"
-                )
-                continue
-            else:
-                cached_plugins[ep_name] = ep.load()(pyproject_dict)
-        if field in cached_plugins[ep_name]:
-            # would be better to update the metadata directly but this is
-            # currently not supported by pyproject_metadata
-            # metadata.__setattr__(field, ep.load()(pyproject_path)
-            pyproject_dict["project"][field] = cached_plugins[ep_name][field]
+
+    plugins = set(settings.metadata.values())
+    cached_plugins = {key: _load(key, pyproject_dict) for key in plugins}
+
+    for field, mod_name in settings.metadata.items():
+        # would be better to update the metadata directly but this is
+        # currently not supported by pyproject_metadata
+        # metadata.__setattr__(field, ep.load()(pyproject_path)
+        if field in cached_plugins[mod_name]:
+            pyproject_dict["project"][field] = cached_plugins[mod_name][field]
             pyproject_dict["project"]["dynamic"].remove(field)
         else:
-            msg = f"{field} is not provided by plugin {ep_name}"
+            msg = f"{field} is not provided by plugin {mod_name}"
             raise KeyError(msg)
 
     # if pyproject-metadata supports updates, we won't need this line anymore

tests/packages/dynamic_metadata/faulty_project.toml

@@ -7,4 +7,4 @@ name = "fancy"
 version = "0.0.1"
 
 [tool.scikit-build.metadata]
-readme = "fancy_pypi_readme"
+readme = "scikit_build_core.metadata.fancy_pypi_readme"

tests/packages/dynamic_metadata/plugin_project.toml

@@ -7,8 +7,8 @@ name = "fancy"
 dynamic = ["readme", "version"]
 
 [tool.scikit-build.metadata]
-version = "setuptools_scm"
-readme = "fancy_pypi_readme"
+version = "scikit_build_core.metadata.setuptools_scm"
+readme = "scikit_build_core.metadata.fancy_pypi_readme"
 
 [tool.setuptools_scm]
 

tests/test_dynamic_metadata.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
+import importlib
 import shutil
 import sys
+import types
 import zipfile
 from pathlib import Path
 from typing import Any
-from unittest import mock
 
 import git
 import pyproject_metadata
 import pytest
 
-from scikit_build_core._compat import importlib, tomllib
+from scikit_build_core._compat import tomllib
 from scikit_build_core.build import build_wheel
 from scikit_build_core.settings.metadata import get_standard_metadata
 from scikit_build_core.settings.skbuild_read_settings import SettingsReader
@@ -53,30 +54,33 @@ def ep_dual(_pyproject_dict: dict[str, Any]) -> dict[str, str | dict[str, str |
     }
 
 
-@pytest.fixture()
-def mock_entry_points():
-    mocked = importlib.metadata.EntryPoints(
-        (
-            importlib.metadata.EntryPoint(  # type: ignore[no-untyped-call]
-                "test_version", f"{__name__}:ep_version", "scikit_build.metadata"
-            ),
-            importlib.metadata.EntryPoint(  # type: ignore[no-untyped-call]
-                "test_license", f"{__name__}:ep_license", "scikit_build.metadata"
-            ),
-            importlib.metadata.EntryPoint(  # type: ignore[no-untyped-call]
-                "test_readme", f"{__name__}:ep_readme", "scikit_build.metadata"
-            ),
-            importlib.metadata.EntryPoint(  # type: ignore[no-untyped-call]
-                "test_dual", f"{__name__}:ep_dual", "scikit_build.metadata"
-            ),
-        )
-    )
+original_loader = importlib.import_module
+
+
+def special_loader(name: str, *args: Any, **kwargs: Any) -> Any:
+    if name == "test_version":
+        test_version = types.ModuleType("test_version")
+        test_version.dynamic_metadata = ep_version  # type: ignore[attr-defined]
+        return test_version
+    if name == "test_readme":
+        test_readme = types.ModuleType("test_readme")
+        test_readme.dynamic_metadata = ep_readme  # type: ignore[attr-defined]
+        return test_readme
+    if name == "test_license":
+        test_license = types.ModuleType("test_license")
+        test_license.dynamic_metadata = ep_license  # type: ignore[attr-defined]
+        return test_license
+    if name == "test_dual":
+        test_dual = types.ModuleType("test_dual")
+        test_dual.dynamic_metadata = ep_dual  # type: ignore[attr-defined]
+        return test_dual
 
-    with mock.patch(
-        "scikit_build_core.settings.metadata.importlib.metadata.entry_points"
-    ) as mocked_eps:
-        mocked_eps.return_value = mocked
-        yield mocked
+    return original_loader(name, *args, **kwargs)
+
+
+@pytest.fixture()
+def mock_entry_points(monkeypatch):
+    monkeypatch.setattr(importlib, "import_module", special_loader)
 
 
 @pytest.mark.usefixtures("mock_entry_points")
@@ -155,7 +159,7 @@ def test_warn_metadata(monkeypatch):
 
     settings_reader.validate_may_exit()
 
-    with pytest.warns():
+    with pytest.raises(ModuleNotFoundError):
         get_standard_metadata(pyproject, settings)