fix: pull in fixes from scikit-build-core (#39)

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

Author: henryiii

src/dynamic_metadata/info.py

@@ -1,7 +1,12 @@
 from __future__ import annotations
 
-__all__ = ["ALL_FIELDS", "DICT_STR_FIELDS", "LIST_STR_FIELDS", "STR_FIELDS"]
-
+__all__ = [
+    "ALL_FIELDS",
+    "DICT_STR_FIELDS",
+    "LIST_DICT_FIELDS",
+    "LIST_STR_FIELDS",
+    "STR_FIELDS",
+]
 
 # Name is not dynamically settable, so not in this list
 STR_FIELDS = frozenset(
@@ -19,32 +24,36 @@
         "classifiers",
         "keywords",
         "dependencies",
-        "license_files",
+        "license-files",
     ]
 )
 
-
 DICT_STR_FIELDS = frozenset(
     [
         "urls",
-        "authors",
-        "maintainers",
         "scripts",
         "gui-scripts",
-        "entry-points",
     ]
 )
 
+LIST_DICT_FIELDS = frozenset(
+    [
+        "authors",
+        "maintainers",
+    ]
+)
 
 # "dynamic" and "name" can't be set or requested
 ALL_FIELDS = (
     STR_FIELDS
     | LIST_STR_FIELDS
     | DICT_STR_FIELDS
+    | LIST_DICT_FIELDS
     | frozenset(
         [
             "optional-dependencies",
             "readme",
+            "entry-points",
         ]
     )
 )

src/dynamic_metadata/plugins/__init__.py

@@ -3,14 +3,17 @@
 import typing
 from collections.abc import Callable
 
-from ..info import DICT_STR_FIELDS, LIST_STR_FIELDS, STR_FIELDS
+from ..info import DICT_STR_FIELDS, LIST_DICT_FIELDS, LIST_STR_FIELDS, STR_FIELDS
 
-T = typing.TypeVar("T", bound="str | list[str] | dict[str, str] | dict[str, list[str]]")
+T = typing.TypeVar(
+    "T",
+    bound="str | list[str] | list[dict[str, str]] | dict[str, str] | dict[str, list[str]] | dict[str, dict[str, str]]",
+)
 
 
 def _process_dynamic_metadata(field: str, action: Callable[[str], str], result: T) -> T:
     """
-    Helper function for processing the an action on the various possible metadata fields.
+    Helper function for processing an action on the various possible metadata fields.
     """
 
     if field in STR_FIELDS:
@@ -29,7 +32,28 @@ def _process_dynamic_metadata(field: str, action: Callable[[str], str], result:
         ):
             msg = f"Field {field!r} must be a dictionary of strings"
             raise RuntimeError(msg)
-        return {k: action(v) for k, v in result.items()}  # type: ignore[return-value]
+        return {action(k): action(v) for k, v in result.items()}  # type: ignore[return-value]
+    if field in LIST_DICT_FIELDS:
+        if not isinstance(result, list) or not all(
+            isinstance(k, str) and isinstance(v, str)
+            for d in result
+            for k, v in d.items()
+        ):
+            msg = f"Field {field!r} must be a dictionary of strings"
+            raise RuntimeError(msg)
+        return [{k: action(v) for k, v in d.items()} for d in result]  # type: ignore[return-value]
+    if field == "entry-points":
+        if not isinstance(result, dict) or not all(
+            isinstance(d, dict)
+            and all(isinstance(k, str) and isinstance(v, str) for k, v in d.items())
+            for d in result.values()
+        ):
+            msg = "Field 'entry-points' must be a dictionary of dictionary of strings"
+            raise RuntimeError(msg)
+        return {
+            dk: {action(k): action(v) for k, v in dv.items()}
+            for dk, dv in result.items()
+        }  # type: ignore[return-value]
     if field == "optional-dependencies":
         if not isinstance(result, dict) or not all(
             isinstance(v, list) for v in result.values()

tests/test_package.py

@@ -1,6 +1,11 @@
 from __future__ import annotations
 
+from typing import Any
+
+import pytest
+
 import dynamic_metadata.loader
+import dynamic_metadata.plugins
 
 
 def test_template_basic() -> None:
@@ -61,12 +66,16 @@ def test_template_entry_points() -> None:
             },
             "entry-points": {
                 "provider": "dynamic_metadata.plugins.template",
-                "result": {"my_point": "my_app:script_{project[version]}"},
+                "result": {
+                    "my_group": {"my_point": "my_app:script_{project[version]}"}
+                },
             },
         },
     )
 
-    assert pyproject["entry-points"] == {"my_point": "my_app:script_1.2.3"}
+    assert pyproject["entry-points"] == {
+        "my_group": {"my_point": "my_app:script_1.2.3"}
+    }
 
 
 def test_regex() -> None:
@@ -87,3 +96,39 @@ def test_regex() -> None:
     )
 
     assert pyproject["requires-python"] == ">=dynamic-metadata"
+
+
+@pytest.mark.parametrize(
+    ("field", "input", "output"),
+    [
+        pytest.param("version", "{sub}", "42", id="str"),
+        pytest.param("classifiers", ["a", "{sub}"], ["a", "42"], id="list-str"),
+        pytest.param(
+            "scripts",
+            {"a": "{sub}", "{sub}": "b"},
+            {"a": "42", "42": "b"},
+            id="dict-str",
+        ),
+        pytest.param(
+            "authors", [{"name": "{sub}"}], [{"name": "42"}], id="list-dict-str"
+        ),
+        pytest.param(
+            "optional-dependencies",
+            {"dev": ["{sub}"]},
+            {"dev": ["42"]},
+            id="dict-list-str",
+        ),
+        pytest.param("readme", {"text": "{sub}"}, {"text": "42"}, id="readme"),
+        pytest.param(
+            "entry-points",
+            {"ep": {"{sub}": "{sub}"}},
+            {"ep": {"42": "42"}},
+            id="dict-dict-str",
+        ),
+    ],
+)
+def test_actions(field: str, input: Any, output: Any) -> None:
+    result = dynamic_metadata.plugins._process_dynamic_metadata(
+        field, lambda x: x.format(sub=42), input
+    )
+    assert output == result