return simplified activation with a extra to prevent regressions

Author: RonnyPfannschmidt

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+### Added
+
+- add simplified activation via `setuptools-scm[simple]` extra
+
+  A new streamlined way to enable version inference without requiring a `[tool.setuptools_scm]` section.
+  When `setuptools-scm[simple]` is in `build-system.requires` and `version` is in `project.dynamic`,
+  version inference is automatically enabled with default settings.
+
+
+### removed
+- unchecked simplified activation - too many projects use setups where it would fail
+
+
 ## v9.1.1
 
 ### fixed

docs/config.md

@@ -2,10 +2,23 @@
 
 ## When is configuration needed?
 
-Starting with setuptools-scm 9.0, explicit configuration is required to enable
-version inference, either via the `[tool.setuptools_scm]` section or the
-`use_scm_version` setup keyword. Listing `setuptools_scm` in `build-system.requires`
-and declaring `project.dynamic = ["version"]` no longer auto-enables inference.
+setuptools-scm provides flexible activation options:
+
+### Simplified Activation (No Configuration Needed)
+
+For basic usage, use the `simple` extra with no configuration:
+
+```toml title="pyproject.toml"
+[build-system]
+requires = ["setuptools>=80", "setuptools-scm[simple]>=8"]
+
+[project]
+dynamic = ["version"]
+```
+
+This automatically enables version inference with default settings.
+
+### Explicit Configuration (Full Control)
 
 Use the `[tool.setuptools_scm]` section when you need to:
   - Write version files (`version_file`)

docs/index.md

@@ -30,21 +30,36 @@ Note: `setuptools-scm>=8` intentionally doesn't depend on setuptools to ease non
 Please ensure a recent version of setuptools is installed (minimum: >=61, recommended: >=80 for best compatibility).
 Support for setuptools <80 is deprecated and will be removed in a future release.
 
+**Simplified setup (recommended for basic usage):**
 
 ```toml title="pyproject.toml"
 [build-system]
-requires = ["setuptools>=80", "setuptools-scm>=8"]
+requires = ["setuptools>=80", "setuptools-scm[simple]>=8"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "example"
 # Important: Remove any existing version declaration
 # version = "0.0.1"
 dynamic = ["version"]
-# more missing
+
+# No additional configuration needed!
+```
+
+**With custom configuration:**
+
+```toml title="pyproject.toml"
+[build-system]
+requires = ["setuptools>=80", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "example"
+dynamic = ["version"]
 
 [tool.setuptools_scm]
-´´´
+# Custom configuration options go here
+```
 
 
 !!! tip "Recommended Tag Format"

docs/usage.md

@@ -7,11 +7,40 @@
     Support for setuptools <80 is deprecated and will be removed in a future release.
     The examples below use `setuptools>=80` as the recommended version.
 
-There are two ways to enable `setuptools-scm` at build time:
+There are three ways to enable `setuptools-scm` at build time:
 
-### Explicit Configuration (required)
+### Simplified Activation (new)
 
-Add a `tool.setuptools_scm` section to explicitly opt-in to version inference:
+For basic usage without custom configuration, use the `simple` extra:
+
+```toml title="pyproject.toml"
+[build-system]
+requires = ["setuptools>=80", "setuptools-scm[simple]>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# version = "0.0.1"  # Remove any existing version parameter.
+dynamic = ["version"]
+
+# No [tool.setuptools_scm] section needed for basic usage!
+```
+
+This streamlined approach automatically enables version inference when:
+- `setuptools-scm[simple]` is listed in `build-system.requires`
+- `version` is included in `project.dynamic`
+
+!!! tip "When to use simplified activation"
+
+    Use simplified activation when you:
+    - Want basic SCM version inference with default settings
+    - Don't need custom version schemes or file writing
+    - Prefer minimal configuration
+
+    Upgrade to explicit configuration if you need customization.
+
+### Explicit Configuration (full control)
+
+Add a `tool.setuptools_scm` section for custom configuration:
 
 ```toml title="pyproject.toml"
 [build-system]
@@ -41,19 +70,16 @@ must ensure build requirements are installed.
 Alternatively, enable `setuptools-scm` via the `use_scm_version` keyword in `setup.py`.
 This also counts as an explicit opt-in and does not require a tool section.
 
-!!! warning "Simplified activation removed"
-
-    Previous documentation described a "simplified" activation where listing
-    `setuptools_scm` in `build-system.requires` together with `project.dynamic = ["version"]`
-    would auto-enable version inference. This behavior has been removed due to
-    regressions and ambiguous activation. You must explicitly opt in via either:
+!!! note "Legacy simplified activation"
 
-    - a `[tool.setuptools_scm]` section, or
-    - the `use_scm_version` setup keyword.
+    Previous versions had a "simplified" activation where listing `setuptools_scm`
+    in `build-system.requires` together with `project.dynamic = ["version"]` would
+    auto-enable version inference. This behavior was removed due to regressions and
+    ambiguous activation.
 
-    The presence of `setuptools_scm` (or `setuptools-scm`) in `build-system.requires`
-    is still recommended to ensure the dependency is available during builds, but it
-    no longer enables version inference by itself.
+    The new simplified activation using the `[simple]` extra provides the same
+    convenience but with explicit opt-in, making it clear when version inference
+    should be enabled.
 
 ### Version files
 

src/setuptools_scm/_integration/pyproject_reading.py

@@ -31,6 +31,7 @@ class PyProjectData:
     is_required: bool
     section_present: bool
     project_present: bool
+    build_requires: list[str]
 
     @classmethod
     def for_testing(
@@ -41,6 +42,8 @@ def for_testing(
         project_present: bool = False,
         project_name: str | None = None,
         has_dynamic_version: bool = True,
+        build_requires: list[str] | None = None,
+        local_scheme: str | None = None,
     ) -> PyProjectData:
         """Create a PyProjectData instance for testing purposes."""
         project: TOML_RESULT
@@ -54,14 +57,22 @@ def for_testing(
         if project_present and has_dynamic_version:
             project["dynamic"] = ["version"]
 
+        if build_requires is None:
+            build_requires = []
+        if local_scheme is not None:
+            assert section_present
+            section = {"local_scheme": local_scheme}
+        else:
+            section = {}
         return cls(
             path=DEFAULT_PYPROJECT_PATH,
             tool_name=DEFAULT_TOOL_NAME,
             project=project,
-            section={},
+            section=section,
             is_required=is_required,
             section_present=section_present,
             project_present=project_present,
+            build_requires=build_requires,
         )
 
     @classmethod
@@ -76,6 +87,7 @@ def empty(
             is_required=False,
             section_present=False,
             project_present=False,
+            build_requires=[],
         )
 
     @property
@@ -95,14 +107,28 @@ def should_infer(self) -> bool:
         """
         Determine if setuptools_scm should infer version based on configuration.
 
-        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.
+        Infer when:
+        1. An explicit [tool.setuptools_scm] section is present, OR
+        2. setuptools-scm[simple] is in build-system.requires AND
+           version is in project.dynamic
 
         Returns:
             True if [tool.setuptools_scm] is present, otherwise False
         """
-        return self.section_present
+        # Original behavior: explicit tool section
+        if self.section_present:
+            return True
+
+        # New behavior: simple extra + dynamic version
+        if self.project_present:
+            dynamic_fields = self.project.get("dynamic", [])
+            if "version" in dynamic_fields:
+                if has_build_package_with_extra(
+                    self.build_requires, "setuptools-scm", "simple"
+                ):
+                    return True
+
+        return False
 
 
 def has_build_package(
@@ -115,6 +141,34 @@ def has_build_package(
     return False
 
 
+def has_build_package_with_extra(
+    requires: Sequence[str], canonical_build_package_name: str, extra_name: str
+) -> bool:
+    """Check if a build dependency has a specific extra.
+
+    Args:
+        requires: List of requirement strings from build-system.requires
+        canonical_build_package_name: The canonical package name to look for
+        extra_name: The extra name to check for (e.g., "simple")
+
+    Returns:
+        True if the package is found with the specified extra
+    """
+    from .._requirement_cls import Requirement
+
+    for requirement_string in requires:
+        try:
+            requirement = Requirement(requirement_string)
+            package_name = extract_package_name(requirement_string)
+            if package_name == canonical_build_package_name:
+                if extra_name in requirement.extras:
+                    return True
+        except Exception:
+            # If parsing fails, continue to next requirement
+            continue
+    return False
+
+
 def read_pyproject(
     path: Path = DEFAULT_PYPROJECT_PATH,
     tool_name: str = DEFAULT_TOOL_NAME,
@@ -160,7 +214,14 @@ def read_pyproject(
     project = defn.get("project", {})
     project_present = "project" in defn
     pyproject_data = PyProjectData(
-        path, tool_name, project, section, is_required, section_present, project_present
+        path,
+        tool_name,
+        project,
+        section,
+        is_required,
+        section_present,
+        project_present,
+        requires,
     )
 
     return pyproject_data

src/setuptools_scm/_requirement_cls.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+__all__ = ["Requirement", "extract_package_name"]
+
 try:
     from packaging.requirements import Requirement
     from packaging.utils import canonicalize_name

testing/test_integration.py

@@ -633,14 +633,12 @@ def test_integration_function_call_order(
 
     # Create PyProjectData with equivalent configuration - no file I/O!
     project_name = "test-call-order"
-    pyproject_data = PyProjectData(
-        path=Path("pyproject.toml"),
-        tool_name="setuptools_scm",
-        project={"name": project_name, "dynamic": ["version"]},
-        section={"local_scheme": "no-local-version"},  # [tool.setuptools_scm] config
-        is_required=True,  # setuptools_scm in build-system.requires
-        section_present=True,  # [tool.setuptools_scm] section exists
-        project_present=True,  # [project] section exists
+    pyproject_data = PyProjectData.for_testing(
+        project_name=project_name,
+        has_dynamic_version=True,
+        project_present=True,
+        section_present=True,
+        local_scheme="no-local-version",
     )
 
     dist = create_clean_distribution(project_name)