refactor step for version inference - intorduce intermediate types and fix/simplify the tests

Author: RonnyPfannschmidt

src/setuptools_scm/_config.py

@@ -291,24 +291,12 @@ def from_file(
         - **kwargs: additional keyword arguments to pass to the Configuration constructor
         """
 
-        try:
-            if pyproject_data is None:
-                pyproject_data = _read_pyproject(
-                    Path(name), missing_section_ok=missing_section_ok
-                )
-        except FileNotFoundError:
-            if missing_file_ok:
-                log.warning("File %s not found, using empty configuration", name)
-                pyproject_data = PyProjectData(
-                    path=Path(name),
-                    tool_name="setuptools_scm",
-                    project={},
-                    section={},
-                    is_required=False,
-                    section_present=False,
-                )
-            else:
-                raise
+        if pyproject_data is None:
+            pyproject_data = _read_pyproject(
+                Path(name),
+                missing_section_ok=missing_section_ok,
+                missing_file_ok=missing_file_ok,
+            )
         args = _get_args_for_pyproject(pyproject_data, dist_name, kwargs)
 
         args.update(read_toml_overrides(args["dist_name"]))

src/setuptools_scm/_integration/pyproject_reading.py

@@ -2,12 +2,11 @@
 
 import warnings
 
+from dataclasses import dataclass
 from pathlib import Path
-from typing import NamedTuple
 from typing import Sequence
 
 from .. import _log
-from .setuptools import read_dist_name_from_setup_cfg
 from .toml import TOML_RESULT
 from .toml import read_toml_content
 
@@ -16,13 +15,39 @@
 _ROOT = "root"
 
 
-class PyProjectData(NamedTuple):
+@dataclass
+class PyProjectData:
     path: Path
     tool_name: str
     project: TOML_RESULT
     section: TOML_RESULT
     is_required: bool
     section_present: bool
+    project_present: bool
+
+    @classmethod
+    def for_testing(
+        cls,
+        is_required: bool = False,
+        section_present: bool = False,
+        project_present: bool = False,
+        project_name: str | None = None,
+    ) -> PyProjectData:
+        """Create a PyProjectData instance for testing purposes."""
+        if project_name is not None:
+            project = {"name": project_name}
+            assert project_present
+        else:
+            project = {}
+        return cls(
+            path=Path("pyproject.toml"),
+            tool_name="setuptools_scm",
+            project=project,
+            section={},
+            is_required=is_required,
+            section_present=section_present,
+            project_present=project_present,
+        )
 
     @property
     def project_name(self) -> str | None:
@@ -33,6 +58,10 @@ def verify_dynamic_version_when_required(self) -> None:
         if self.is_required and not self.section_present:
             # When setuptools-scm is in build-system.requires but no tool section exists,
             # we need to verify that dynamic=['version'] is set in the project section
+            # But only if there's actually a project section
+            if not self.project_present:
+                # No project section, so don't auto-activate setuptools_scm
+                return
             dynamic = self.project.get("dynamic", [])
             if "version" not in dynamic:
                 raise ValueError(
@@ -62,8 +91,25 @@ def read_pyproject(
     tool_name: str = "setuptools_scm",
     build_package_names: Sequence[str] = ("setuptools_scm", "setuptools-scm"),
     missing_section_ok: bool = False,
+    missing_file_ok: bool = False,
 ) -> PyProjectData:
-    defn = read_toml_content(path)
+    try:
+        defn = read_toml_content(path)
+    except FileNotFoundError:
+        if missing_file_ok:
+            log.warning("File %s not found, using empty configuration", path)
+            return PyProjectData(
+                path=path,
+                tool_name=tool_name,
+                project={},
+                section={},
+                is_required=False,
+                section_present=False,
+                project_present=False,
+            )
+        else:
+            raise
+
     requires: list[str] = defn.get("build-system", {}).get("requires", [])
     is_required = has_build_package(requires, build_package_names)
 
@@ -87,8 +133,9 @@ def read_pyproject(
             section_present = False
 
     project = defn.get("project", {})
+    project_present = "project" in defn
     pyproject_data = PyProjectData(
-        path, tool_name, project, section, is_required, section_present
+        path, tool_name, project, section, is_required, section_present, project_present
     )
 
     # Verify dynamic version when setuptools-scm is used as build dependency indicator
@@ -121,8 +168,6 @@ def get_args_for_pyproject(
     if dist_name is None:
         # minimal pep 621 support for figuring the pretend keys
         dist_name = pyproject.project_name
-    if dist_name is None:
-        dist_name = read_dist_name_from_setup_cfg()
     if _ROOT in kwargs:
         if kwargs[_ROOT] is None:
             kwargs.pop(_ROOT, None)

src/setuptools_scm/_integration/setup_cfg.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+
+import setuptools
+
+
+def read_dist_name_from_setup_cfg(
+    input: str | os.PathLike[str] = "setup.cfg",
+) -> str | None:
+    # minimal effort to read dist_name off setup.cfg metadata
+    import configparser
+
+    parser = configparser.ConfigParser()
+    parser.read([input], encoding="utf-8")
+    dist_name = parser.get("metadata", "name", fallback=None)
+    return dist_name
+
+
+def _dist_name_from_legacy(dist: setuptools.Distribution) -> str | None:
+    return dist.metadata.name or read_dist_name_from_setup_cfg()

src/setuptools_scm/_integration/setuptools.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-import os
 import warnings
 
 from pathlib import Path
@@ -11,22 +10,16 @@
 import setuptools
 
 from .. import _config
+from .pyproject_reading import read_pyproject
+from .setup_cfg import _dist_name_from_legacy
+from .version_inference import VersionInferenceConfig
+from .version_inference import VersionInferenceError
+from .version_inference import VersionInferenceException
+from .version_inference import get_version_inference_config
 
 log = logging.getLogger(__name__)
 
 
-def read_dist_name_from_setup_cfg(
-    input: str | os.PathLike[str] = "setup.cfg",
-) -> str | None:
-    # minimal effort to read dist_name off setup.cfg metadata
-    import configparser
-
-    parser = configparser.ConfigParser()
-    parser.read([input], encoding="utf-8")
-    dist_name = parser.get("metadata", "name", fallback=None)
-    return dist_name
-
-
 def _warn_on_old_setuptools(_version: str = setuptools.__version__) -> None:
     if int(_version.split(".")[0]) < 61:
         warnings.warn(
@@ -85,14 +78,15 @@ def _assign_version(
 
 
 def _log_hookstart(hook: str, dist: setuptools.Distribution) -> None:
-    log.debug("%s %r", hook, vars(dist.metadata))
+    log.debug("%s %s %s %r", hook, id(dist), id(dist.metadata), vars(dist.metadata))
 
 
 def version_keyword(
     dist: setuptools.Distribution,
     keyword: str,
     value: bool | dict[str, Any] | Callable[[], dict[str, Any]],
 ) -> None:
+    # Parse overrides (integration point responsibility)
     overrides: dict[str, Any]
     if value is True:
         overrides = {}
@@ -105,73 +99,96 @@ def version_keyword(
     assert "dist_name" not in overrides, (
         "dist_name may not be specified in the setup keyword "
     )
-    dist_name: str | None = dist.metadata.name
+
+    dist_name: str | None = _dist_name_from_legacy(dist)
+
+    was_set_by_infer = getattr(dist, "_setuptools_scm_version_set_by_infer", False)
     _log_hookstart("version_keyword", dist)
 
-    if dist.metadata.version is not None:
-        # Check if version was set by infer_version
-        was_set_by_infer = getattr(dist, "_setuptools_scm_version_set_by_infer", False)
+    # Get pyproject data
+    try:
+        pyproject_data = read_pyproject(
+            Path("pyproject.toml"), missing_section_ok=True, missing_file_ok=True
+        )
+    except (LookupError, ValueError) as e:
+        log.debug("Configuration issue in pyproject.toml: %s", e)
+        return
 
+    # Get decision
+    result = get_version_inference_config(
+        dist_name=dist_name,
+        current_version=dist.metadata.version,
+        pyproject_data=pyproject_data,
+        overrides=overrides,
+        was_set_by_infer=was_set_by_infer,
+    )
+
+    # Handle result
+    if result is None:
+        return  # Don't infer
+    elif isinstance(result, VersionInferenceError):
+        if result.should_warn:
+            warnings.warn(result.message)
+        return
+    elif isinstance(result, VersionInferenceException):
+        raise result.exception
+    elif isinstance(result, VersionInferenceConfig):
+        # Clear version if it was set by infer_version
         if was_set_by_infer:
-            # Version was set by infer_version, check if we have overrides
-            if not overrides:
-                # No overrides, just use the infer_version result
-                return
-            # We have overrides, clear the marker and proceed to override the version
             dist._setuptools_scm_version_set_by_infer = False  # type: ignore[attr-defined]
             dist.metadata.version = None
-        else:
-            # Version was set by something else, warn and return
-            warnings.warn(f"version of {dist_name} already set")
-            return
-
-    if dist_name is None:
-        dist_name = read_dist_name_from_setup_cfg()
 
-    config = _config.Configuration.from_file(
-        dist_name=dist_name,
-        missing_file_ok=True,
-        missing_section_ok=True,
-        **overrides,
-    )
-    _assign_version(dist, config)
+        # Proceed with inference
+        config = _config.Configuration.from_file(
+            dist_name=result.dist_name,
+            pyproject_data=result.pyproject_data,
+            missing_file_ok=True,
+            missing_section_ok=True,
+            **overrides,
+        )
+        _assign_version(dist, config)
 
 
 def infer_version(dist: setuptools.Distribution) -> None:
     _log_hookstart("infer_version", dist)
-    log.debug("dist %s %s", id(dist), id(dist.metadata))
-    if dist.metadata.version is not None:
-        return  # metadata already added by hook
-    dist_name = dist.metadata.name
-    if dist_name is None:
-        dist_name = read_dist_name_from_setup_cfg()
-    if not os.path.isfile("pyproject.toml"):
-        return
-    if dist_name == "setuptools-scm":
-        return
 
-    # Check if setuptools-scm is configured before proceeding
-    try:
-        from .pyproject_reading import read_pyproject
+    dist_name = _dist_name_from_legacy(dist)
 
+    # Get pyproject data (integration point responsibility)
+    try:
         pyproject_data = read_pyproject(Path("pyproject.toml"), missing_section_ok=True)
-        # Only proceed if setuptools-scm is either in build_requires or has a tool section
-        if not pyproject_data.is_required and not pyproject_data.section_present:
-            return  # No setuptools-scm configuration, silently return
-    except (FileNotFoundError, LookupError):
-        return  # No pyproject.toml or other issues, silently return
-    except ValueError as e:
-        # Log the error as debug info instead of raising it
+    except FileNotFoundError:
+        log.debug("pyproject.toml not found")
+        return
+    except (LookupError, ValueError) as e:
         log.debug("Configuration issue in pyproject.toml: %s", e)
-        return  # Configuration issue, silently return
+        return
 
-    try:
-        config = _config.Configuration.from_file(
-            dist_name=dist_name, pyproject_data=pyproject_data
-        )
-    except LookupError as e:
-        log.info(e, exc_info=True)
-    else:
-        _assign_version(dist, config)
-        # Mark that this version was set by infer_version
-        dist._setuptools_scm_version_set_by_infer = True  # type: ignore[attr-defined]
+    # Get decision
+    result = get_version_inference_config(
+        dist_name=dist_name,
+        current_version=dist.metadata.version,
+        pyproject_data=pyproject_data,
+    )
+
+    # Handle result
+    if result is None:
+        return  # Don't infer
+    elif isinstance(result, VersionInferenceError):
+        if result.should_warn:
+            log.warning(result.message)
+        return
+    elif isinstance(result, VersionInferenceException):
+        raise result.exception
+    elif isinstance(result, VersionInferenceConfig):
+        # Proceed with inference
+        try:
+            config = _config.Configuration.from_file(
+                dist_name=result.dist_name, pyproject_data=result.pyproject_data
+            )
+        except LookupError as e:
+            log.info(e, exc_info=True)
+        else:
+            _assign_version(dist, config)
+            # Mark that this version was set by infer_version
+            dist._setuptools_scm_version_set_by_infer = True  # type: ignore[attr-defined]