undo support for simplified enabling

Author: RonnyPfannschmidt

src/setuptools_scm/_integration/pyproject_reading.py

@@ -85,39 +85,14 @@ 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).
+        Only infer when an explicit [tool.setuptools_scm] section is present.
+        The presence of setuptools-scm in build-system.requires or
+        project.dynamic does NOT auto-enable inference.
 
         Returns:
-            True if version inference should proceed based on configuration
-
-        Raises:
-            ValueError: If setuptools-scm is required but dynamic=['version'] is missing
+            True if [tool.setuptools_scm] is present, otherwise False
         """
-        # 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
+        return self.section_present
 
 
 def has_build_package(

src/setuptools_scm/_integration/setuptools.py

@@ -138,6 +138,7 @@ def infer_version(
         log.debug("Configuration issue in pyproject.toml: %s", e)
         return
 
+    # Only infer when tool section present per get_version_inference_config
     result = _get_version_inference_config(
         dist_name=dist_name,
         current_version=legacy_data.version or pyproject_data.project.get("version"),

src/setuptools_scm/_integration/version_inference.py

@@ -149,14 +149,10 @@ def get_version_inference_config(
             dist_name=dist_name, pyproject_data=pyproject_data, overrides=overrides
         )
 
-    # infer_version path: decide based on pyproject configuration only
-    try:
-        if pyproject_data.should_infer():
-            return VersionInferenceConfig(
-                dist_name=dist_name, pyproject_data=pyproject_data, overrides=None
-            )
-    except ValueError:
-        # Auto-activation should not error in infer_version context → skip silently
-        return VersionInferenceNoOp()
+    # infer_version path: only infer when [tool.setuptools_scm] section is present
+    if pyproject_data.should_infer():
+        return VersionInferenceConfig(
+            dist_name=dist_name, pyproject_data=pyproject_data, overrides=None
+        )
 
     return VersionInferenceNoOp()

testing/test_integration.py

@@ -739,7 +739,7 @@ def test_git_archival_plugin_ignored(tmp_path: Path, ep_name: str) -> None:
 
 
 def test_pyproject_build_system_requires_setuptools_scm(wd: WorkDir) -> None:
-    """Test that setuptools_scm is enabled when present in build-system.requires"""
+    """With only build-system.requires and dynamic version, no auto-enable without tool section."""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")
 
@@ -761,13 +761,13 @@ def test_pyproject_build_system_requires_setuptools_scm(wd: WorkDir) -> None:
     wd.write("setup.py", "__import__('setuptools').setup()")
 
     res = wd([sys.executable, "setup.py", "--version"])
-    assert res.endswith("0.1.dev0+d20090213")
+    assert res == "0.0.0"
 
 
 def test_pyproject_build_system_requires_setuptools_scm_dash_variant(
     wd: WorkDir,
 ) -> None:
-    """Test that setuptools-scm (dash variant) is also detected in build-system.requires"""
+    """Dash variant also does not auto-enable without tool section."""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")
 
@@ -789,9 +789,12 @@ def test_pyproject_build_system_requires_setuptools_scm_dash_variant(
     wd.write("setup.py", "__import__('setuptools').setup()")
 
     res = wd([sys.executable, "setup.py", "--version"])
-    assert res.endswith("0.1.dev0+d20090213")
+    assert res == "0.0.0"
 
 
+@pytest.mark.xfail(
+    reason="we currently dont support dynamic version without tool section"
+)
 def test_pyproject_build_system_requires_with_extras(wd: WorkDir) -> None:
     """Test that setuptools_scm[toml] is detected in build-system.requires"""
     if sys.version_info < (3, 11):
@@ -847,7 +850,7 @@ def test_pyproject_build_system_requires_not_present(wd: WorkDir) -> None:
 def test_pyproject_build_system_requires_priority_over_tool_section(
     wd: WorkDir,
 ) -> None:
-    """Test that both build-system.requires and [tool.setuptools_scm] section work together"""
+    """Tool section controls enablement; build-system.requires may coexist."""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")
 
@@ -887,7 +890,7 @@ def test_extract_package_name(base_name: str, requirements: str) -> None:
 
 
 def test_build_requires_integration_with_config_reading(wd: WorkDir) -> None:
-    """Test that Configuration.from_file handles build-system.requires automatically"""
+    """Configuration.from_file still accepts build-system.requires without tool section."""
     if sys.version_info < (3, 11):
         pytest.importorskip("tomli")
 
@@ -1092,6 +1095,9 @@ def test_integration_function_call_order(
     )
 
 
+@pytest.mark.xfail(
+    reason="we currently dont support dynamic version without tool section"
+)
 def test_infer_version_with_build_requires_no_tool_section(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -1119,14 +1125,14 @@ def test_infer_version_with_build_requires_no_tool_section(
     # Call infer_version with direct data injection - no file I/O!
     infer_version(dist, _given_pyproject_data=pyproject_data)
 
-    # Verify that version was set
-    assert dist.metadata.version is not None
     assert dist.metadata.version == "1.0.0"
 
-    # Verify that the marker was set
     assert getattr(dist, "_setuptools_scm_version_set_by_infer", False) is True
 
 
+@pytest.mark.xfail(
+    reason="we currently dont support dynamic version without tool section"
+)
 def test_infer_version_with_build_requires_dash_variant_no_tool_section(
     wd: WorkDir, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -1154,11 +1160,8 @@ def test_infer_version_with_build_requires_dash_variant_no_tool_section(
     # Call infer_version with direct data injection - no file I/O!
     infer_version(dist, _given_pyproject_data=pyproject_data)
 
-    # Verify that version was set
-    assert dist.metadata.version is not None
     assert dist.metadata.version == "1.0.0"
 
-    # Verify that the marker was set
     assert getattr(dist, "_setuptools_scm_version_set_by_infer", False) is True
 
 
@@ -1221,6 +1224,9 @@ def test_version_keyword_no_scm_dependency_works(
     assert dist.metadata.version == "1.0.0"
 
 
+@pytest.mark.xfail(
+    reason="we currently dont support dynamic version without tool section"
+)
 def test_verify_dynamic_version_when_required_missing_dynamic() -> None:
     """Test that should_infer raises ValueError when setuptools-scm is in build-system.requires but dynamic=['version'] is missing"""
     from setuptools_scm._integration.pyproject_reading import PyProjectData
@@ -1261,6 +1267,9 @@ def test_verify_dynamic_version_when_required_with_tool_section() -> None:
     assert pyproject_data.should_infer() is True
 
 
+@pytest.mark.xfail(
+    reason="we currently dont support dynamic version without tool section"
+)
 def test_verify_dynamic_version_when_required_with_dynamic() -> None:
     """Test that verification passes when setuptools-scm is in build-system.requires and dynamic=['version'] is set"""
     from setuptools_scm._integration.pyproject_reading import PyProjectData

testing/test_version_inference.py

@@ -89,7 +89,7 @@ def test_no_setuptools_scm_config_infer_version(self) -> None:
         assert isinstance(result, VersionInferenceNoOp)
 
     def test_no_setuptools_scm_config_version_keyword(self) -> None:
-        """Test that we DO infer when setuptools-scm is not configured but use_scm_version=True."""
+        """We infer when setuptools-scm is not configured but use_scm_version=True."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version=None,
@@ -102,7 +102,7 @@ def test_no_setuptools_scm_config_version_keyword(self) -> None:
         assert result.overrides == {}
 
     def test_setuptools_scm_required_no_project_section_infer_version(self) -> None:
-        """Test that we don't infer when setuptools-scm is required but no project section and infer_version called."""
+        """We don't infer without tool section even if required: infer_version path."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version=None,
@@ -142,18 +142,17 @@ def test_setuptools_scm_required_no_project_section_version_keyword_with_config(
         assert result.overrides == overrides
 
     def test_setuptools_scm_required_with_project_section(self) -> None:
-        """Test that we infer when setuptools-scm is required and project section exists."""
+        """We only infer when tool section present, regardless of required/project presence."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version=None,
             pyproject_data=PyProjectData.for_testing(True, False, True),
         )
 
-        assert isinstance(result, VersionInferenceConfig)
-        assert result.dist_name == "test_package"
+        assert isinstance(result, VersionInferenceNoOp)
 
     def test_tool_section_present(self) -> None:
-        """Test that we infer when tool section is present."""
+        """We infer when tool section is present."""
         result = get_version_inference_config(
             dist_name="test_package",
             current_version=None,