revise version inference logic

- drop magic boolean parameters
- drop unused exception creator
- simplify calls

Author: RonnyPfannschmidt

src/setuptools_scm/_integration/setuptools.py

@@ -89,6 +89,10 @@ def version_keyword(
 
     was_set_by_infer = getattr(dist, "_setuptools_scm_version_set_by_infer", False)
 
+    # Exit early if overrides is empty dict AND version was set by infer
+    if overrides == {} and was_set_by_infer:
+        return
+
     # Get pyproject data (support direct injection for tests)
     try:
         pyproject_data = read_pyproject(_given_result=_given_pyproject_data)
@@ -99,12 +103,18 @@ def version_keyword(
         log.debug("Configuration issue in pyproject.toml: %s", e)
         return
 
+    # Pass None as current_version if overrides is truthy AND version was set by infer
+    current_version = (
+        None
+        if (overrides and was_set_by_infer)
+        else (legacy_data.version or pyproject_data.project_version)
+    )
+
     result = _get_version_inference_config(
         dist_name=dist_name,
-        current_version=legacy_data.version or pyproject_data.project_version,
+        current_version=current_version,
         pyproject_data=pyproject_data,
         overrides=overrides,
-        was_set_by_infer=was_set_by_infer,
     )
 
     result.apply(dist)

src/setuptools_scm/_integration/version_inference.py

@@ -27,13 +27,6 @@ def apply(self, dist: Any) -> None:
         from .._get_version_impl import _get_version
         from .._get_version_impl import _version_missing
 
-        # Clear version if it was set by infer_version (overrides is None means infer_version context)
-        # OR if we have overrides (version_keyword context) and the version was set by infer_version
-        was_set_by_infer = getattr(dist, "_setuptools_scm_version_set_by_infer", False)
-        if was_set_by_infer and (self.overrides is None or self.overrides):
-            dist._setuptools_scm_version_set_by_infer = False
-            dist.metadata.version = None
-
         config = _config_module.Configuration.from_file(
             dist_name=self.dist_name,
             pyproject_data=self.pyproject_data,
@@ -45,7 +38,6 @@ def apply(self, dist: Any) -> None:
         if maybe_version is None:
             _version_missing(config)
         else:
-            assert dist.metadata.version is None
             dist.metadata.version = maybe_version
 
         # Mark that this version was set by infer_version if overrides is None (infer_version context)
@@ -68,17 +60,6 @@ def apply(self, dist: Any) -> None:
             warnings.warn(self.message)
 
 
-@dataclass
-class VersionInferenceException:
-    """Exception that should be raised."""
-
-    exception: Exception
-
-    def apply(self, dist: Any) -> None:
-        """Apply exception handling to the distribution."""
-        raise self.exception
-
-
 class VersionInferenceNoOp:
     """No operation result - silent skip."""
 
@@ -89,7 +70,6 @@ def apply(self, dist: Any) -> None:
 VersionInferenceResult = Union[
     VersionInferenceConfig,  # Proceed with inference
     VersionInferenceError,  # Show error/warning
-    VersionInferenceException,  # Raise exception
     VersionInferenceNoOp,  # Don't infer (silent)
 ]
 
@@ -99,7 +79,6 @@ def get_version_inference_config(
     current_version: str | None,
     pyproject_data: PyProjectData,
     overrides: dict[str, Any] | None = None,
-    was_set_by_infer: bool = False,
 ) -> VersionInferenceResult:
     """
     Determine whether and how to perform version inference.
@@ -109,7 +88,6 @@ def get_version_inference_config(
         current_version: Current version if any
         pyproject_data: PyProjectData from parser (None if file doesn't exist)
         overrides: Override configuration (None for no overrides)
-        was_set_by_infer: Whether current version was set by infer_version
 
     Returns:
         VersionInferenceResult with the decision and configuration
@@ -118,41 +96,33 @@ def get_version_inference_config(
     if dist_name is None:
         dist_name = pyproject_data.project_name
 
-    # If a version is already present, decide based on context (infer_version vs version_keyword)
+    # Never infer a version for setuptools-scm itself
+    if dist_name == "setuptools-scm":
+        return VersionInferenceNoOp()
+
+    # If a version already exists, short-circuit by context
     if current_version is not None:
-        # infer_version call (overrides is None) should be a no-op if version already exists
         if overrides is None:
+            # infer_version called and a version is already present → do nothing
             return VersionInferenceNoOp()
-
-        if not was_set_by_infer:
+        else:
+            # version_keyword context - always warn if version already set
             return VersionInferenceError(
                 f"version of {dist_name} already set",
                 should_warn=pyproject_data.should_infer(),
             )
 
-        # Version was set by infer_version previously
-        if overrides:
-            # Non-empty overrides from version_keyword → re-infer with overrides
-            return VersionInferenceConfig(
-                dist_name=dist_name, pyproject_data=pyproject_data, overrides=overrides
-            )
-        # Empty overrides dict from version_keyword → keep existing version
-        return VersionInferenceNoOp()
-
-    # Do not infer a version for setuptools-scm itself
-    if dist_name == "setuptools-scm":
-        return VersionInferenceNoOp()
-
-    # version_keyword path: any overrides (empty or not) mean we should infer
+    # No version present yet
     if overrides is not None:
+        # version_keyword path: any overrides (empty or not) mean we should infer
         return VersionInferenceConfig(
             dist_name=dist_name, pyproject_data=pyproject_data, overrides=overrides
         )
 
-    # infer_version path: only infer when [tool.setuptools_scm] section is present
+    # infer_version path: only infer when [tool.setuptools_scm] is present
     if pyproject_data.should_infer():
         return VersionInferenceConfig(
-            dist_name=dist_name, pyproject_data=pyproject_data, overrides=None
+            dist_name=dist_name, pyproject_data=pyproject_data, overrides=overrides
         )
 
     return VersionInferenceNoOp()

src/setuptools_scm/_types.py

@@ -55,6 +55,5 @@ def __call__(
         current_version: str | None,
         pyproject_data: PyProjectData,
         overrides: dict[str, object] | None = None,
-        was_set_by_infer: bool = False,
     ) -> VersionInferenceApplicable:  # pragma: no cover - structural type
         ...

testing/test_version_inference.py

@@ -3,51 +3,47 @@
 from setuptools_scm._integration.pyproject_reading import PyProjectData
 from setuptools_scm._integration.version_inference import VersionInferenceConfig
 from setuptools_scm._integration.version_inference import VersionInferenceError
-from setuptools_scm._integration.version_inference import VersionInferenceException
 from setuptools_scm._integration.version_inference import VersionInferenceNoOp
 from setuptools_scm._integration.version_inference import get_version_inference_config
 
 
 class TestVersionInferenceDecision:
     """Test the version inference decision logic."""
 
-    def test_version_already_set_by_infer_with_overrides(self) -> None:
-        """Test that we proceed when version was set by infer_version but overrides provided."""
+    def test_version_already_set_with_overrides(self) -> None:
+        """Test that we get an error when version is already set and overrides provided."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version="1.0.0",
             pyproject_data=PyProjectData.for_testing(True, True, True),
             overrides={"key": "value"},
-            was_set_by_infer=True,
         )
 
-        assert isinstance(result, VersionInferenceConfig)
-        assert result.dist_name == "test_package"
-        assert result.overrides == {"key": "value"}
+        assert isinstance(result, VersionInferenceError)
+        assert "version of test_package already set" in result.message
 
-    def test_version_already_set_by_infer_no_overrides(self) -> None:
+    def test_version_already_set_no_overrides(self) -> None:
         """infer_version call with existing version should be a no-op."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version="1.0.0",
             pyproject_data=PyProjectData.for_testing(True, True, True),
             overrides=None,
-            was_set_by_infer=True,
         )
 
         assert isinstance(result, VersionInferenceNoOp)
 
-    def test_version_already_set_by_infer_empty_overrides(self) -> None:
-        """Test that we don't re-infer when version was set by infer_version with empty overrides (version_keyword call)."""
+    def test_version_already_set_empty_overrides(self) -> None:
+        """Test that we get an error when version is already set with empty overrides (version_keyword call)."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version="1.0.0",
             pyproject_data=PyProjectData.for_testing(True, True, True),
             overrides={},
-            was_set_by_infer=True,
         )
 
-        assert isinstance(result, VersionInferenceNoOp)
+        assert isinstance(result, VersionInferenceError)
+        assert "version of test_package already set" in result.message
 
     def test_version_already_set_by_something_else(self) -> None:
         """infer_version call with existing version set by something else should be a no-op."""
@@ -56,7 +52,6 @@ def test_version_already_set_by_something_else(self) -> None:
             current_version="1.0.0",
             pyproject_data=PyProjectData.for_testing(True, True, True),
             overrides=None,
-            was_set_by_infer=False,
         )
 
         assert isinstance(result, VersionInferenceNoOp)
@@ -83,7 +78,8 @@ def test_no_setuptools_scm_config_infer_version(self) -> None:
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(False, False, True),
-            overrides=None,  # infer_version call
+            overrides=None,
+            # infer_version call
         )
 
         assert isinstance(result, VersionInferenceNoOp)
@@ -94,7 +90,8 @@ def test_no_setuptools_scm_config_version_keyword(self) -> None:
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(False, False, True),
-            overrides={},  # version_keyword call with use_scm_version=True
+            overrides={},
+            # version_keyword call with use_scm_version=True
         )
 
         assert isinstance(result, VersionInferenceConfig)
@@ -107,7 +104,8 @@ def test_setuptools_scm_required_no_project_section_infer_version(self) -> None:
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(True, False, False),
-            overrides=None,  # infer_version call
+            overrides=None,
+            # infer_version call
         )
 
         assert isinstance(result, VersionInferenceNoOp)
@@ -118,7 +116,8 @@ def test_setuptools_scm_required_no_project_section_version_keyword(self) -> Non
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(True, False, False),
-            overrides={},  # version_keyword call with use_scm_version=True
+            overrides={},
+            # version_keyword call with use_scm_version=True
         )
 
         assert isinstance(result, VersionInferenceConfig)
@@ -134,7 +133,8 @@ def test_setuptools_scm_required_no_project_section_version_keyword_with_config(
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(True, False, False),
-            overrides=overrides,  # version_keyword call with use_scm_version={config}
+            overrides=overrides,
+            # version_keyword call with use_scm_version={config}
         )
 
         assert isinstance(result, VersionInferenceConfig)
@@ -191,7 +191,6 @@ def test_version_already_set_none_dist_name(self) -> None:
             current_version="1.0.0",
             pyproject_data=PyProjectData.for_testing(True, True, True),
             overrides=None,
-            was_set_by_infer=False,
         )
 
         assert isinstance(result, VersionInferenceNoOp)
@@ -260,13 +259,3 @@ def test_error_default_warn(self) -> None:
         """Test VersionInferenceError default should_warn value."""
         error = VersionInferenceError("test message")
         assert error.should_warn is False
-
-
-class TestVersionInferenceException:
-    """Test the VersionInferenceException dataclass."""
-
-    def test_exception_creation(self) -> None:
-        """Test creating VersionInferenceException instances."""
-        original_exception = ValueError("test error")
-        wrapper = VersionInferenceException(original_exception)
-        assert wrapper.exception == original_exception