Refactor version inference logic to use should_infer method for dynamic version verification

- Introduced should_infer method in PyProjectData to determine if version inference should proceed based on configuration.
- Updated version_inference.py to utilize should_infer for handling version inference conditions.
- Modified tests to reflect changes in dynamic version verification and ensure proper error handling when dynamic=['version'] is missing.

Author: RonnyPfannschmidt

src/setuptools_scm/_integration/pyproject_reading.py

@@ -33,13 +33,20 @@ def for_testing(
         section_present: bool = False,
         project_present: bool = False,
         project_name: str | None = None,
+        has_dynamic_version: bool = True,
     ) -> PyProjectData:
         """Create a PyProjectData instance for testing purposes."""
+        project: TOML_RESULT
         if project_name is not None:
             project = {"name": project_name}
             assert project_present
         else:
             project = {}
+
+        # If project is present and has_dynamic_version is True, add dynamic=['version']
+        if project_present and has_dynamic_version:
+            project["dynamic"] = ["version"]
+
         return cls(
             path=Path("pyproject.toml"),
             tool_name="setuptools_scm",
@@ -54,22 +61,43 @@ def for_testing(
     def project_name(self) -> str | None:
         return self.project.get("name")
 
-    def verify_dynamic_version_when_required(self) -> None:
-        """Verify that dynamic=['version'] is set when setuptools-scm is used as build dependency indicator."""
-        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(
-                    f"{self.path}: setuptools-scm is present in [build-system].requires "
-                    f"but dynamic=['version'] is not set in [project]. "
-                    f"Either add dynamic=['version'] to [project] or add a [tool.{self.tool_name}] section."
-                )
+    def should_infer(self) -> bool:
+        """
+        Determine if setuptools_scm should infer version based on configuration.
+
+        This method only considers the pyproject.toml configuration state.
+        It does not consider version_keyword context (overrides always infer).
+
+        Returns:
+            True if version inference should proceed based on configuration
+
+        Raises:
+            ValueError: If setuptools-scm is required but dynamic=['version'] is missing
+        """
+        # If there's a tool section, always infer
+        if self.section_present:
+            return True
+
+        # If not required, don't auto-activate for infer_version
+        if not self.is_required:
+            return False
+
+        # setuptools-scm is required but no tool section
+        if not self.project_present:
+            # No project section - don't auto-activate
+            return False
+
+        # Project section exists - check for dynamic=['version']
+        dynamic = self.project.get("dynamic", [])
+        if "version" not in dynamic:
+            raise ValueError(
+                f"{self.path}: setuptools-scm is present in [build-system].requires "
+                f"but dynamic=['version'] is not set in [project]. "
+                f"Either add dynamic=['version'] to [project] or add a [tool.{self.tool_name}] section."
+            )
+
+        # All conditions met
+        return True
 
 
 def has_build_package(
@@ -134,9 +162,6 @@ def read_pyproject(
         path, tool_name, project, section, is_required, section_present, project_present
     )
 
-    # Verify dynamic version when setuptools-scm is used as build dependency indicator
-    pyproject_data.verify_dynamic_version_when_required()
-
     return pyproject_data
 
 

src/setuptools_scm/_integration/version_inference.py

@@ -152,31 +152,26 @@ def get_version_inference_config(
     if dist_name == "setuptools-scm":
         return VersionInferenceNoOp()
 
-    # Handle missing configuration
-    if not pyproject_data.is_required and not pyproject_data.section_present:
-        # If version_keyword was called (overrides is not None), activate setuptools_scm
-        # This handles both use_scm_version=True (empty {}) and use_scm_version={config}
-        if overrides is not None:
-            return VersionInferenceConfig(
-                dist_name=dist_name,
-                pyproject_data=pyproject_data,
-                overrides=overrides,
-            )
-        # If infer_version was called (overrides is None), only activate with config
-        return VersionInferenceNoOp()
+    # version_keyword (with overrides) always tries to infer
+    if overrides is not None:
+        return VersionInferenceConfig(
+            dist_name=dist_name,
+            pyproject_data=pyproject_data,
+            overrides=overrides,
+        )
 
-    # Handle missing project section when required
-    if (
-        pyproject_data.is_required
-        and not pyproject_data.section_present
-        and not pyproject_data.project_present
-        and overrides is None  # Only return NoOp for infer_version, not version_keyword
-    ):
+    # infer_version (no overrides) uses pyproject configuration to decide
+    try:
+        should_proceed = pyproject_data.should_infer()
+    except ValueError:
+        # For infer_version, silently skip on configuration issues (auto-activation shouldn't error)
         return VersionInferenceNoOp()
 
-    # All conditions met - proceed with inference
-    return VersionInferenceConfig(
-        dist_name=dist_name,
-        pyproject_data=pyproject_data,
-        overrides=overrides,
-    )
+    if should_proceed:
+        return VersionInferenceConfig(
+            dist_name=dist_name,
+            pyproject_data=pyproject_data,
+            overrides=overrides,
+        )
+    else:
+        return VersionInferenceNoOp()

testing/test_integration.py

@@ -1181,7 +1181,7 @@ def test_version_keyword_no_scm_dependency_works(
 def test_verify_dynamic_version_when_required_missing_dynamic(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Test that verification fails when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
+    """Test that should_infer raises ValueError when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")
 
@@ -1202,11 +1202,14 @@ def test_verify_dynamic_version_when_required_missing_dynamic(
 
     from setuptools_scm._integration.pyproject_reading import read_pyproject
 
-    # This should raise a ValueError because dynamic=['version'] is missing
+    # Read pyproject data first
+    pyproject_data = read_pyproject(Path("pyproject.toml"), missing_section_ok=True)
+
+    # should_infer should raise a ValueError when dynamic=['version'] is missing
     with pytest.raises(
         ValueError, match="dynamic=\\['version'\\] is not set in \\[project\\]"
     ):
-        read_pyproject(Path("pyproject.toml"), missing_section_ok=True)
+        pyproject_data.should_infer()
 
 
 def test_verify_dynamic_version_when_required_with_tool_section(
@@ -1240,6 +1243,9 @@ def test_verify_dynamic_version_when_required_with_tool_section(
     assert pyproject_data.is_required is True
     assert pyproject_data.section_present is True
 
+    # should_infer should return True because tool section exists
+    assert pyproject_data.should_infer() is True
+
 
 def test_verify_dynamic_version_when_required_with_dynamic(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
@@ -1270,11 +1276,14 @@ def test_verify_dynamic_version_when_required_with_dynamic(
     assert pyproject_data.is_required is True
     assert pyproject_data.section_present is False
 
+    # should_infer should return True because dynamic=['version'] is set
+    assert pyproject_data.should_infer() is True
+
 
 def test_infer_version_logs_debug_when_missing_dynamic_version(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Test that infer_version logs debug info when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
+    """Test that infer_version gracefully handles and logs debug info when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")