chore: address review feedback on ft ABI logic

- Add `_PyTag` helper class to `wheel_tag.py` to make the
  complex `all()` ABI tag checks readable; refactor `compute_best`
  to use it
- Restructure the `limited_api` block in `builder.py`: move the
  `cp3*t` branch inside the `cp3` check, add a warning when the
  free-threaded stable ABI is requested but conditions aren't met,
  and move the classic-on-free-threaded warning into the inner branch
- Promote the inline `VersionInfo` test helper to module level in
  `tests/test_builder.py` and add a `from_str()` classmethod

Assisted-by: Copilot:claude-sonnet-4.6
Signed-off-by: Henry Schreiner <henryfs@princeton.edu>

Author: henryiii

src/scikit_build_core/builder/builder.py

@@ -212,20 +212,41 @@ def configure(
         py_api = self.settings.wheel.py_api
         ft_abi = False
         if limited_api is None:
-            if py_api.startswith("cp3") and py_api.endswith("t"):
-                target_minor_version = int(py_api[3:-1])
-                ft_abi = (
-                    sys.implementation.name == "cpython"
-                    and sysconfig.get_config_var("Py_GIL_DISABLED")
-                    and target_minor_version <= sys.version_info.minor
-                )
-                limited_api = ft_abi
-            elif py_api.startswith("cp3"):
-                target_minor_version = int(py_api[3:])
-                limited_api = target_minor_version <= sys.version_info.minor
+            if py_api.startswith("cp3"):
+                if py_api.endswith("t"):
+                    # Free-threaded stable ABI (PEP 803 / abi3t)
+                    target_minor_version = int(py_api[3:-1])
+                    if (
+                        sys.implementation.name == "cpython"
+                        and sysconfig.get_config_var("Py_GIL_DISABLED")
+                        and target_minor_version <= sys.version_info.minor
+                    ):
+                        ft_abi = True
+                        limited_api = True
+                    else:
+                        limited_api = False
+                        logger.info(
+                            "py-api {} requires free-threaded CPython >= 3.{}, ignoring",
+                            py_api,
+                            target_minor_version,
+                        )
+                else:
+                    # Classic stable ABI (abi3)
+                    target_minor_version = int(py_api[3:])
+                    if sys.implementation.name != "cpython":
+                        limited_api = False
+                        logger.info("PyPy doesn't support the Limited API, ignoring")
+                    elif sysconfig.get_config_var("Py_GIL_DISABLED"):
+                        limited_api = False
+                        logger.info(
+                            "Free-threaded Python doesn't support the classic Limited API, ignoring"
+                        )
+                    else:
+                        limited_api = target_minor_version <= sys.version_info.minor
             else:
                 limited_api = False
 
+        # Handle externally-set limited_api (e.g. from setuptools)
         if (limited_api or ft_abi) and sys.implementation.name != "cpython":
             limited_api = False
             ft_abi = False

src/scikit_build_core/builder/wheel_tag.py

@@ -24,6 +24,35 @@ def __dir__() -> list[str]:
     return __all__
 
 
+class _PyTag:
+    """Helper for interrogating a single Python ABI tag like 'cp39' or 'cp315t'."""
+
+    def __init__(self, tag: str) -> None:
+        self._tag = tag
+
+    @property
+    def is_classic_abi3(self) -> bool:
+        return self._tag.startswith("cp3") and self._tag[3:].isdecimal()
+
+    @property
+    def is_ft_abi3(self) -> bool:
+        return (
+            self._tag.startswith("cp3")
+            and self._tag.endswith("t")
+            and len(self._tag) > 4
+            and self._tag[3:-1].isdecimal()
+        )
+
+    @property
+    def minor(self) -> int:
+        if self.is_ft_abi3:
+            return int(self._tag[3:-1])
+        return int(self._tag[3:])
+
+    def __str__(self) -> str:
+        return self._tag
+
+
 @dataclasses.dataclass(frozen=True)
 class WheelTag:
     pyvers: list[str]
@@ -99,64 +128,47 @@ def compute_best(
 
         if py_api:
             pyvers_new = py_api.split(".")
+            pytags = [_PyTag(x) for x in pyvers_new]
+            gil_disabled = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
             if all(
-                (
-                    x.startswith("cp3")
-                    and x[3:].isdecimal()
-                    and not sysconfig.get_config_var("Py_GIL_DISABLED")
-                )
-                or (
-                    x.startswith("cp3")
-                    and len(x) > 4
-                    and x[3:-1].isdecimal()
-                    and x.endswith("t")
-                    and sysconfig.get_config_var("Py_GIL_DISABLED")
-                )
-                for x in pyvers_new
+                (t.is_classic_abi3 and not gil_disabled)
+                or (t.is_ft_abi3 and gil_disabled)
+                for t in pytags
             ):
                 if root_is_purelib:
                     msg = f"Unexpected py-api, since platlib is set to false, must be Pythonless (e.g. py2.py3), not {py_api}"
                     raise AssertionError(msg)
 
-                # Separate classic and free-threaded tags
-                classic_tags = [
-                    x for x in pyvers_new if x.startswith("cp3") and x[3:].isdecimal()
-                ]
-                ft_tags = [
-                    x
-                    for x in pyvers_new
-                    if x.startswith("cp3")
-                    and len(x) > 4
-                    and x[3:-1].isdecimal()
-                    and x.endswith("t")
-                ]
-
-                if sys.implementation.name == "cpython" and sysconfig.get_config_var(
-                    "Py_GIL_DISABLED"
-                ):
+                classic_tags = [t for t in pytags if t.is_classic_abi3]
+                ft_tags = [t for t in pytags if t.is_ft_abi3]
+
+                if sys.implementation.name == "cpython" and gil_disabled:
                     # Free-threaded: only accept cp3XXt tags
                     if ft_tags:
                         target = ft_tags[0]
-                        minor = int(target[3:-1])
-                        if minor <= sys.version_info.minor:
-                            pyvers = [target]
+                        if target.minor <= sys.version_info.minor:
+                            pyvers = [str(target)]
                             abi = "abi3t"
                         else:
-                            msg = "Ignoring py-api, version (3.{}) is too high"
-                            logger.debug(msg, minor)
+                            logger.debug(
+                                "Ignoring py-api, version (3.{}) is too high",
+                                target.minor,
+                            )
                 # Classic CPython
                 elif classic_tags:
                     target = classic_tags[0]
-                    minor = int(target[3:])
                     if (
                         sys.implementation.name == "cpython"
-                        and minor <= sys.version_info.minor
+                        and target.minor <= sys.version_info.minor
                     ):
-                        pyvers = [target]
+                        pyvers = [str(target)]
                         abi = "abi3"
                     else:
-                        msg = "Ignoring py-api, not a CPython interpreter ({}) or version (3.{}) is too high"
-                        logger.debug(msg, sys.implementation.name, minor)
+                        logger.debug(
+                            "Ignoring py-api, not a CPython interpreter ({}) or version (3.{}) is too high",
+                            sys.implementation.name,
+                            target.minor,
+                        )
             elif all(x.startswith("py") and x[2:].isdecimal() for x in pyvers_new):
                 pyvers = pyvers_new
                 abi = "none"
@@ -221,5 +233,5 @@ def as_tags_set(self) -> frozenset[packaging.tags.Tag]:
         help="Specify a non-platlib (pure) tag",
     )
     args = parser.parse_args()
-    tag = WheelTag.compute_best(args.archs, args.abi, root_is_purelib=args.purelib)
-    print(tag)  # noqa: T201
+    comp_tag = WheelTag.compute_best(args.archs, args.abi, root_is_purelib=args.purelib)
+    print(comp_tag)  # noqa: T201

tests/test_builder.py

@@ -30,6 +30,38 @@
 )
 
 
+class VersionInfo:
+    """Minimal sys.version_info replacement for monkeypatching in tests."""
+
+    def __init__(
+        self,
+        major: int,
+        minor: int,
+        micro: int = 0,
+        releaselevel: str = "final",
+        serial: int = 0,
+    ) -> None:
+        self.major = major
+        self.minor = minor
+        self.micro = micro
+        self.releaselevel = releaselevel
+        self.serial = serial
+
+    @classmethod
+    def from_str(cls, version: str) -> VersionInfo:
+        major, minor, *rest = (int(x) for x in version.split("."))
+        micro = rest[0] if rest else 0
+        return cls(major, minor, micro)
+
+    def __getitem__(self, index: int) -> int | str:
+        return (self.major, self.minor, self.micro, self.releaselevel, self.serial)[
+            index
+        ]
+
+    def __ge__(self, other: tuple[int, ...]) -> bool:
+        return (self.major, self.minor, self.micro) >= other[:3]
+
+
 # The envvar_higher case shouldn't happen, but the compiler should cause the
 # correct failure
 @pytest.mark.parametrize(
@@ -288,29 +320,6 @@ def test_wheel_tag_with_abi3t_darwin(monkeypatch):
     monkeypatch.setenv("MACOSX_DEPLOYMENT_TARGET", "10.10")
     monkeypatch.setattr(platform, "mac_ver", lambda: ("10.9.2", "", ""))
 
-    class VersionInfo:
-        def __init__(
-            self,
-            major: int,
-            minor: int,
-            micro: int = 0,
-            releaselevel: str = "final",
-            serial: int = 0,
-        ) -> None:
-            self.major = major
-            self.minor = minor
-            self.micro = micro
-            self.releaselevel = releaselevel
-            self.serial = serial
-
-        def __getitem__(self, index: int) -> int | str:
-            return (self.major, self.minor, self.micro, self.releaselevel, self.serial)[
-                index
-            ]
-
-        def __ge__(self, other: tuple[int, ...]) -> bool:
-            return (self.major, self.minor, self.micro) >= other[:3]
-
     monkeypatch.setattr(sys, "version_info", VersionInfo(3, 15))
 
     tags = WheelTag.compute_best(["x86_64"], py_api="cp315t")