feat: add template dynamic-metadata plugin and dynamic_metadata_needs

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

docs/configuration/dynamic.md

@@ -52,7 +52,7 @@ dynamic_version()
 project(MyPackage VERSION ${PROJECT_VERSION})
 ```
 
-## `version`: Regex
+## Regex
 
 If you want to pull a string-valued expression (usually version) from an
 existing file, you can the integrated `regex` plugin to pull the information.
@@ -112,6 +112,31 @@ metadata.readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
 # tool.hatch.metadata.hooks.fancy-pypi-readme options here
 ```
 
+```{versionchanged} 0.11.2
+
+The version number feature now works.
+```
+
+## Template
+
+You can access other metadata fields and produce templated outputs.
+
+```toml
+[tool.scikit-build.metadata.optional-dependencies]
+provider = "scikit_build_core.metadata.template"
+needs = ["version"]
+result = {"dev" = ["subpackage=={project.version}"]}
+```
+
+You can specify `needs` to ensure other metadata is computed before this one.
+You can use `result` to specify the output. The result must match the type of
+the metadata field you are writing to. You can use `project` to access the current
+metadata values.
+
+```{versionadded} 0.11.2
+
+```
+
 ## `build-system.requires`: Scikit-build-core's `build.requires`
 
 If you need to inject and manipulate additional `build-system.requires`, you can

pyproject.toml

@@ -39,6 +39,7 @@ dependencies = [
     "pathspec >=0.10.1",
     "tomli >=1.2.2; python_version<'3.11'",
     "typing-extensions >=3.10.0; python_version<'3.9'",
+    "graphlib_backport >=1; python_version<'3.9'",
 ]
 # Note: cmake and possibly ninja are also required if those are not already
 # present (user controllable) - but a system version is fine.
@@ -182,7 +183,7 @@ disallow_untyped_defs = true
 disallow_incomplete_defs = true
 
 [[tool.mypy.overrides]]
-module = ["numpy", "pathspec", "setuptools_scm", "hatch_fancy_pypi_readme", "virtualenv"]
+module = ["numpy", "pathspec", "setuptools_scm", "hatch_fancy_pypi_readme", "virtualenv", "graphlib_backport"]
 ignore_missing_imports = true
 
 
@@ -301,6 +302,7 @@ known-local-folder = ["pathutils"]
 "importlib.resources".msg = "Use scikit_build_core._compat.importlib.resources instead."
 "importlib_resources".msg = "Use scikit_build_core._compat.importlib.resources instead."
 "pyproject_metadata".msg = "Use scikit_build_core._vendor.pyproject_metadata instead."
+"graphlib".msg = "Use scikit_build_core._compat.graphlib instead."
 
 
 [tool.ruff.lint.per-file-ignores]

src/scikit_build_core/build/metadata.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import inspect
 import sys
 from typing import TYPE_CHECKING, Any
 
@@ -13,7 +14,7 @@
     extras_build_system,
     extras_top_level,
 )
-from ..settings._load_provider import load_dynamic_metadata
+from ..builder._load_provider import load_dynamic_metadata
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -34,7 +35,6 @@ def __dir__() -> list[str]:
     errors.ExceptionGroup = ExceptionGroup  # type: ignore[misc, assignment]
 
 
-# If pyproject-metadata eventually supports updates, this can be simplified
 def get_standard_metadata(
     pyproject_dict: Mapping[str, Any],
     settings: ScikitBuildSettings,
@@ -49,7 +49,17 @@ def get_standard_metadata(
         if field not in pyproject_dict.get("project", {}).get("dynamic", []):
             msg = f"{field} is not in project.dynamic"
             raise KeyError(msg)
-        new_pyproject_dict["project"][field] = provider.dynamic_metadata(field, config)
+
+        sig = inspect.signature(provider.dynamic_metadata)
+        if len(sig.parameters) < 3:
+            # Backcompat for dynamic_metadata without metadata dict
+            new_pyproject_dict["project"][field] = provider.dynamic_metadata(  # type: ignore[call-arg]
+                field, config
+            )
+        else:
+            new_pyproject_dict["project"][field] = provider.dynamic_metadata(
+                field, config, new_pyproject_dict["project"].copy()
+            )
         new_pyproject_dict["project"]["dynamic"].remove(field)
 
     if settings.strict_config:

src/scikit_build_core/settings/_load_provider.py renamed to src/scikit_build_core/builder/_load_provider.py

@@ -3,7 +3,9 @@
 import importlib
 import sys
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Protocol, Union
+from typing import TYPE_CHECKING, Any, Protocol, Union, runtime_checkable
+
+from .._compat.graphlib import TopologicalSorter
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable, Mapping
@@ -15,34 +17,41 @@ def __dir__() -> list[str]:
     return __all__
 
 
+@runtime_checkable
 class DynamicMetadataProtocol(Protocol):
     def dynamic_metadata(
-        self, fields: Iterable[str], settings: dict[str, Any]
+        self, fields: Iterable[str], settings: dict[str, Any], metadata: dict[str, Any]
     ) -> dict[str, Any]: ...
 
 
+@runtime_checkable
 class DynamicMetadataRequirementsProtocol(DynamicMetadataProtocol, Protocol):
     def get_requires_for_dynamic_metadata(
         self, settings: dict[str, Any]
     ) -> list[str]: ...
 
 
+@runtime_checkable
 class DynamicMetadataWheelProtocol(DynamicMetadataProtocol, Protocol):
     def dynamic_wheel(
         self, field: str, settings: Mapping[str, Any] | None = None
     ) -> bool: ...
 
 
-class DynamicMetadataRequirementsWheelProtocol(
-    DynamicMetadataRequirementsProtocol, DynamicMetadataWheelProtocol, Protocol
-): ...
+@runtime_checkable
+class DynamicMetadataNeeds(DynamicMetadataProtocol, Protocol):
+    def dynamic_metadata_needs(
+        self,
+        field: str,
+        settings: Mapping[str, object] | None = None,
+    ) -> list[str]: ...
 
 
 DMProtocols = Union[
     DynamicMetadataProtocol,
     DynamicMetadataRequirementsProtocol,
     DynamicMetadataWheelProtocol,
-    DynamicMetadataRequirementsWheelProtocol,
+    DynamicMetadataNeeds,
 ]
 
 
@@ -64,14 +73,31 @@ def load_provider(
         sys.path.pop(0)
 
 
-def load_dynamic_metadata(
+def _load_dynamic_metadata(
     metadata: Mapping[str, Mapping[str, str]],
-) -> Generator[tuple[str, DMProtocols | None, dict[str, str]], None, None]:
+) -> Generator[
+    tuple[str, DMProtocols | None, dict[str, str], frozenset[str]], None, None
+]:
     for field, orig_config in metadata.items():
         if "provider" in orig_config:
             config = dict(orig_config)
             provider = config.pop("provider")
             provider_path = config.pop("provider-path", None)
-            yield field, load_provider(provider, provider_path), config
+            loaded_provider = load_provider(provider, provider_path)
+            needs = frozenset(
+                loaded_provider.dynamic_metadata_needs(field, config)
+                if isinstance(loaded_provider, DynamicMetadataNeeds)
+                else []
+            )
+            yield field, loaded_provider, config, needs
         else:
-            yield field, None, dict(orig_config)
+            yield field, None, dict(orig_config), frozenset()
+
+
+def load_dynamic_metadata(
+    metadata: Mapping[str, Mapping[str, str]],
+) -> list[tuple[str, DMProtocols | None, dict[str, str]]]:
+    initial = {f: (p, c, n) for (f, p, c, n) in _load_dynamic_metadata(metadata)}
+    sorter = TopologicalSorter({f: n for f, (_, _, n) in initial.items()})
+    order = sorter.static_order()
+    return [(f, *initial[f][:2]) for f in order]

src/scikit_build_core/builder/get_requires.py

@@ -19,8 +19,8 @@
     get_ninja_programs,
 )
 from ..resources import resources
-from ..settings._load_provider import load_provider
 from ..settings.skbuild_read_settings import SettingsReader
+from ._load_provider import load_provider
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Mapping

src/scikit_build_core/metadata/__init__.py

@@ -1,3 +1,31 @@
 from __future__ import annotations
 
-__all__: list[str] = []
+__all__: list[str] = ["_DICT_LIST_FIELDS", "_LIST_STR_FIELDS", "_STR_FIELDS"]
+
+
+# Name is not dynamically settable, so not in this list
+_STR_FIELDS = frozenset(
+    [
+        "version",
+        "description",
+        "requires-python",
+        "license",
+    ]
+)
+
+# Dynamic is not dynamically settable, so not in this list
+_LIST_STR_FIELDS = frozenset(
+    [
+        "classifiers",
+        "keywords",
+        "dependencies",
+        "license_files",
+    ]
+)
+
+_DICT_LIST_FIELDS = frozenset(
+    [
+        "urls",
+        "optional-dependencies",
+    ]
+)

src/scikit_build_core/metadata/fancy_pypi_readme.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Any
 
 from .._compat import tomllib
 
-__all__ = ["dynamic_metadata", "get_requires_for_dynamic_metadata"]
+__all__ = [
+    "dynamic_metadata",
+    "dynamic_requires_needs",
+    "get_requires_for_dynamic_metadata",
+]
 
 
 def __dir__() -> list[str]:
@@ -13,7 +18,8 @@ def __dir__() -> list[str]:
 
 def dynamic_metadata(
     field: str,
-    settings: dict[str, list[str] | str] | None = None,
+    settings: dict[str, list[str] | str],
+    metadata: dict[str, Any],
 ) -> str | dict[str, str]:
     from hatch_fancy_pypi_readme._builder import build_text
     from hatch_fancy_pypi_readme._config import load_and_validate_config
@@ -36,7 +42,9 @@ def dynamic_metadata(
     if hasattr(config, "substitutions"):
         try:
             # We don't have access to the version at this point
-            text = build_text(config.fragments, config.substitutions, "")
+            text = build_text(
+                config.fragments, config.substitutions, version=metadata["version"]
+            )
         except TypeError:
             # Version 23.2.0 and before don't have a version field
             # pylint: disable-next=no-value-for-parameter
@@ -56,3 +64,10 @@ def get_requires_for_dynamic_metadata(
     _settings: dict[str, object] | None = None,
 ) -> list[str]:
     return ["hatch-fancy-pypi-readme>=22.3"]
+
+
+def dynamic_requires_needs(
+    _field: str,
+    _settings: dict[str, object],
+) -> list[str]:
+    return ["version"]

src/scikit_build_core/metadata/regex.py

@@ -4,6 +4,8 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from . import _STR_FIELDS
+
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
@@ -22,7 +24,7 @@ def dynamic_metadata(
     settings: Mapping[str, Any],
 ) -> str:
     # Input validation
-    if field not in {"version", "description", "requires-python"}:
+    if field not in _STR_FIELDS:
         msg = "Only string fields supported by this plugin"
         raise RuntimeError(msg)
     if settings.keys() > KEYS:

tests/packages/dynamic_metadata/plugin_project.toml

@@ -4,12 +4,17 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "fancy"
-dynamic = ["readme", "version"]
+dynamic = ["readme", "version", "optional-dependencies"]
 
 [tool.scikit-build.metadata]
 version.provider = "scikit_build_core.metadata.setuptools_scm"
 readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
 
+[tool.scikit-build.metadata.optional-dependencies]
+provider = "scikit_build_core.metadata.template"
+needs = ["version", "name"]
+result = {"dev" = ["{name}=={version}"]}
+
 [tool.setuptools_scm]
 
 [tool.hatch.metadata.hooks.fancy-pypi-readme]
@@ -19,4 +24,4 @@ content-type = "text/x-rst"
 text = "Fragment #1"
 
 [[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
-text = "Fragment #2"
+text = "Fragment #2 -- $HFPR_VERSION"

tests/test_dynamic_metadata.py

@@ -10,6 +10,7 @@
 from typing import TYPE_CHECKING, Any
 
 import pytest
+from packaging.requirements import Requirement
 from packaging.version import Version
 
 from scikit_build_core._compat import tomllib
@@ -145,14 +146,16 @@ def test_plugin_metadata():
 
     assert str(metadata.version) == "0.1.0"
     assert metadata.readme == pyproject_metadata.Readme(
-        "Fragment #1Fragment #2", None, "text/x-rst"
+        "Fragment #1Fragment #2 -- 0.1.0", None, "text/x-rst"
     )
 
     assert set(GetRequires().dynamic_metadata()) == {
         "hatch-fancy-pypi-readme>=22.3",
         "setuptools-scm",
     }
 
+    assert metadata.optional_dependencies == {"dev": [Requirement("fancy==0.1.0")]}
+
 
 @pytest.mark.usefixtures("package_dynamic_metadata")
 def test_faulty_metadata():