refactor: implicit needs

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

Author: henryiii

docs/configuration/dynamic.md

@@ -124,14 +124,12 @@ 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}"]}
+result = {"dev" = ["{project[name]}=={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.
+ You can use `project` to access the current metadata values. You can reference
+other dynamic metadata fields, and they will be 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.
 
 ```{versionadded} 0.11.2
 

pyproject.toml

@@ -39,7 +39,6 @@ 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.
@@ -183,7 +182,7 @@ disallow_untyped_defs = true
 disallow_incomplete_defs = true
 
 [[tool.mypy.overrides]]
-module = ["numpy", "pathspec", "setuptools_scm", "hatch_fancy_pypi_readme", "virtualenv", "graphlib"]
+module = ["numpy", "pathspec", "setuptools_scm", "hatch_fancy_pypi_readme", "virtualenv"]
 ignore_missing_imports = true
 
 

src/scikit_build_core/build/metadata.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import copy
-import inspect
 import sys
 from typing import TYPE_CHECKING, Any
 
@@ -39,28 +38,12 @@ def get_standard_metadata(
     pyproject_dict: Mapping[str, Any],
     settings: ScikitBuildSettings,
 ) -> StandardMetadata:
-    new_pyproject_dict = copy.deepcopy(pyproject_dict)
+    new_pyproject_dict = copy.deepcopy(dict(pyproject_dict))
 
     # Handle any dynamic metadata
-    for field, provider, config in load_dynamic_metadata(settings.metadata):
-        if provider is None:
-            msg = f"{field} is missing provider"
-            raise KeyError(msg)
-        if field not in pyproject_dict.get("project", {}).get("dynamic", []):
-            msg = f"{field} is not in project.dynamic"
-            raise KeyError(msg)
-
-        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)
+    new_pyproject_dict["project"] = load_dynamic_metadata(
+        new_pyproject_dict["project"], settings.metadata
+    )
 
     if settings.strict_config:
         extra_keys_top = extras_top_level(new_pyproject_dict)

src/scikit_build_core/builder/_load_provider.py

@@ -1,14 +1,19 @@
 from __future__ import annotations
 
+import dataclasses
 import importlib
+import inspect
 import sys
+from collections.abc import Iterator, Mapping
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Protocol, Union, runtime_checkable
 
-from graphlib import TopologicalSorter
-
 if TYPE_CHECKING:
-    from collections.abc import Generator, Iterable, Mapping
+    from collections.abc import Generator, Iterable
+
+    StrMapping = Mapping[str, Any]
+else:
+    StrMapping = Mapping
 
 from ..metadata import _ALL_FIELDS
 
@@ -22,7 +27,10 @@ def __dir__() -> list[str]:
 @runtime_checkable
 class DynamicMetadataProtocol(Protocol):
     def dynamic_metadata(
-        self, fields: Iterable[str], settings: dict[str, Any], metadata: dict[str, Any]
+        self,
+        fields: Iterable[str],
+        settings: dict[str, Any],
+        metadata: Mapping[str, Any],
     ) -> dict[str, Any]: ...
 
 
@@ -40,20 +48,10 @@ def dynamic_wheel(
     ) -> bool: ...
 
 
-@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,
-    DynamicMetadataNeeds,
 ]
 
 
@@ -77,39 +75,76 @@ def load_provider(
 
 def _load_dynamic_metadata(
     metadata: Mapping[str, Mapping[str, str]],
-) -> Generator[
-    tuple[str, DMProtocols | None, dict[str, str], frozenset[str]], None, None
-]:
+) -> Generator[tuple[str, DMProtocols, dict[str, str]], None, None]:
     for field, orig_config in metadata.items():
-        if "provider" in orig_config:
-            if field not in _ALL_FIELDS:
-                msg = f"{field} is not a valid field"
-                raise KeyError(msg)
-            config = dict(orig_config)
-            provider = config.pop("provider")
-            provider_path = config.pop("provider-path", None)
-            loaded_provider = load_provider(provider, provider_path)
-            needs = frozenset(
-                loaded_provider.dynamic_metadata_needs(field, config)
-                if isinstance(loaded_provider, DynamicMetadataNeeds)
-                else []
+        if "provider" not in orig_config:
+            msg = "Missing provider in dynamic metadata"
+            raise KeyError(msg)
+
+        if field not in _ALL_FIELDS:
+            msg = f"{field} is not a valid field"
+            raise KeyError(msg)
+        config = dict(orig_config)
+        provider = config.pop("provider")
+        provider_path = config.pop("provider-path", None)
+        loaded_provider = load_provider(provider, provider_path)
+        yield field, loaded_provider, config
+
+
+@dataclasses.dataclass
+class DynamicSettings(StrMapping):
+    settings: dict[str, dict[str, Any]]
+    project: dict[str, Any]
+    providers: dict[str, DMProtocols]
+
+    def __getitem__(self, key: str) -> Any:
+        # Try to get the settings from either the static file or dynamic metadata provider
+        if key in self.project:
+            return self.project[key]
+
+        # Check if we are in a loop, i.e. something else is already requesting
+        # this key while trying to get another key
+        if key not in self.providers:
+            dep_type = "missing" if key in self.settings else "circular"
+            msg = f"Encountered a {dep_type} dependency at {key}"
+            raise ValueError(msg)
+
+        provider = self.providers.pop(key)
+        sig = inspect.signature(provider.dynamic_metadata)
+        if len(sig.parameters) < 3:
+            # Backcompat for dynamic_metadata without metadata dict
+            self.project[key] = provider.dynamic_metadata(  # type: ignore[call-arg]
+                key, self.settings[key]
             )
-            if needs > _ALL_FIELDS:
-                msg = f"Invalid dyanmic_metada_needs: {needs - _ALL_FIELDS}"
-                raise KeyError(msg)
-            yield field, loaded_provider, config, needs
         else:
-            yield field, None, dict(orig_config), frozenset()
+            self.project[key] = provider.dynamic_metadata(
+                key, self.settings[key], self.project
+            )
+        self.project["dynamic"].remove(key)
+
+        return self.project[key]
+
+    def __iter__(self) -> Iterator[str]:
+        # Iterate over the keys of the static settings
+        yield from self.project
+
+        # Iterate over the keys of the dynamic metadata providers
+        yield from self.providers
+
+    def __len__(self) -> int:
+        return len(self.project) + len(self.providers)
 
 
 def load_dynamic_metadata(
+    project: Mapping[str, Any],
     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)}
+) -> dict[str, Any]:
+    initial = {f: (p, c) for (f, p, c) in _load_dynamic_metadata(metadata)}
 
-    dynamic_fields = initial.keys()
-    sorter = TopologicalSorter(
-        {f: n & dynamic_fields for f, (_, _, n) in initial.items()}
+    settings = DynamicSettings(
+        settings={f: c for f, (v, c) in initial.items()},
+        project=dict(project),
+        providers={k: v for k, (v, _) in initial.items()},
     )
-    order = sorter.static_order()
-    return [(f, *initial[f][:2]) for f in order]
+
+    return dict(settings)

src/scikit_build_core/metadata/fancy_pypi_readme.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from .._compat import tomllib
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
 __all__ = [
     "dynamic_metadata",
-    "dynamic_requires_needs",
     "get_requires_for_dynamic_metadata",
 ]
 
@@ -19,7 +21,7 @@ def __dir__() -> list[str]:
 def dynamic_metadata(
     field: str,
     settings: dict[str, list[str] | str],
-    metadata: dict[str, Any],
+    metadata: Mapping[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
@@ -64,10 +66,3 @@ 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/template.py

@@ -7,14 +7,14 @@
 
 from . import _process_dynamic_metadata
 
-__all__ = ["dynamic_metadata", "dynamic_metadata_needs"]
+__all__ = ["dynamic_metadata"]
 
 
 def __dir__() -> list[str]:
     return __all__
 
 
-KEYS = {"needs", "result"}
+KEYS = {"result"}
 
 
 def dynamic_metadata(
@@ -34,13 +34,6 @@ def dynamic_metadata(
 
     return _process_dynamic_metadata(
         field,
-        lambda r: r.format(**metadata),
+        lambda r: r.format(project=metadata),
         result,
     )
-
-
-def dynamic_metadata_needs(
-    field: str,  # noqa: ARG001
-    settings: Mapping[str, Any],
-) -> list[str]:
-    return settings.get("needs", [])

tests/packages/dynamic_metadata/plugin_project.toml

@@ -12,8 +12,7 @@ readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
 
 [tool.scikit-build.metadata.optional-dependencies]
 provider = "scikit_build_core.metadata.template"
-needs = ["version"]
-result = {"dev" = ["{name}=={version}"]}
+result = {"dev" = ["{project[name]}=={project[version]}"]}
 
 [tool.setuptools_scm]
 

tests/test_dynamic_metadata.py

@@ -159,6 +159,9 @@ def test_plugin_metadata():
 
 @pytest.mark.usefixtures("package_dynamic_metadata")
 def test_faulty_metadata():
+    reason_msg = "install hatch-fancy-pypi-readme to test the dynamic metadata plugins"
+    pytest.importorskip("hatch_fancy_pypi_readme", reason=reason_msg)
+
     with Path("faulty_project.toml").open("rb") as ft:
         pyproject = tomllib.load(ft)
     settings_reader = SettingsReader(pyproject, {}, state="metadata_wheel")