first working iteration on build tag passover from scm tags to version strings

addresses #1019
needs more iteration

Author: RonnyPfannschmidt

src/setuptools_scm/_overrides.py

@@ -164,8 +164,7 @@ def _read_pretended_version_for(
     pretended = read_named_env(name="PRETEND_VERSION", dist_name=config.dist_name)
 
     if pretended:
-        # we use meta here since the pretended version
-        # must adhere to the pep to begin with
+        # Use enhanced meta function - let validation errors bubble up
         return version.meta(tag=pretended, preformatted=True, config=config)
     else:
         return None

src/setuptools_scm/fallbacks.py

@@ -25,6 +25,7 @@ def parse_pkginfo(root: _t.PathT, config: Configuration) -> ScmVersion | None:
     data = data_from_mime(pkginfo)
     version = data.get("Version", _UNKNOWN)
     if version != _UNKNOWN:
+        # Use enhanced meta function - let validation errors bubble up
         return meta(version, preformatted=True, config=config)
     else:
         return None
@@ -38,8 +39,10 @@ def fallback_version(root: _t.PathT, config: Configuration) -> ScmVersion | None
                 parent_name[len(config.parentdir_prefix_version) :], config
             )
             if version is not None:
+                # Use enhanced meta function - let validation errors bubble up
                 return meta(str(version), preformatted=True, config=config)
     if config.fallback_version is not None:
         log.debug("FALLBACK %s", config.fallback_version)
+        # Use enhanced meta function - let validation errors bubble up
         return meta(config.fallback_version, preformatted=True, config=config)
     return None

src/setuptools_scm/version.py

@@ -152,8 +152,8 @@ def _source_epoch_or_utc_now() -> datetime:
 class ScmVersion:
     """represents a parsed version from scm"""
 
-    tag: _v.Version | _v.NonNormalizedVersion | str
-    """the related tag or preformatted version string"""
+    tag: _v.Version | _v.NonNormalizedVersion
+    """the related tag or preformatted version"""
     config: _config.Configuration
     """the configuration used to parse the version"""
     distance: int = 0
@@ -223,9 +223,16 @@ def format_next_version(
 
 def _parse_tag(
     tag: _VersionT | str, preformatted: bool, config: _config.Configuration
-) -> _VersionT | str:
+) -> _VersionT:
     if preformatted:
-        return tag
+        # For preformatted versions, tag should already be validated as a version object
+        # String validation is handled in meta function before calling this
+        if isinstance(tag, str):
+            # This should not happen with enhanced meta, but kept for safety
+            return _v.NonNormalizedVersion(tag)
+        else:
+            # Already a version object (including test mocks), return as-is
+            return tag
     elif not isinstance(tag, config.version_cls):
         version = tag_to_version(tag, config)
         assert version is not None
@@ -246,7 +253,16 @@ def meta(
     node_date: date | None = None,
     time: datetime | None = None,
 ) -> ScmVersion:
-    parsed_version = _parse_tag(tag, preformatted, config)
+    parsed_version: _VersionT
+    # Enhanced string validation for preformatted versions
+    if preformatted and isinstance(tag, str):
+        # Validate PEP 440 compliance using NonNormalizedVersion
+        # Let validation errors bubble up to the caller
+        parsed_version = _v.NonNormalizedVersion(tag)
+    else:
+        # Use existing _parse_tag logic for non-preformatted or already validated inputs
+        parsed_version = _parse_tag(tag, preformatted, config)
+
     log.info("version %s -> %s", tag, parsed_version)
     assert parsed_version is not None, f"Can't parse version {tag}"
     scm_version = ScmVersion(
@@ -533,8 +549,7 @@ def format_version(version: ScmVersion) -> str:
     log.debug("scm version %s", version)
     log.debug("config %s", version.config)
     if version.preformatted:
-        assert isinstance(version.tag, str)
-        return version.tag
+        return str(version.tag)
 
     # Extract original tag's local data for later combination
     original_local = ""
@@ -544,23 +559,10 @@ def format_version(version: ScmVersion) -> str:
     # Create a patched ScmVersion with only the base version (no local data) for version schemes
     from dataclasses import replace
 
-    if version.tag:
-        # Extract the base version (public part) from the tag using config's version_cls
-        if hasattr(version.tag, "public"):
-            # It's a Version object with a public attribute
-            base_version_str = str(version.tag.public)
-        elif isinstance(version.tag, str):
-            # It's a string - strip any local part
-            base_version_str = version.tag.split("+")[0]
-        else:
-            # It's some other type - use string representation and strip local part
-            base_version_str = str(version.tag).split("+")[0]
-
-        # Create the base tag using the config's version class
-        base_tag = version.config.version_cls(base_version_str)
-        version_for_scheme = replace(version, tag=base_tag)
-    else:
-        version_for_scheme = version
+    # Extract the base version (public part) from the tag using config's version_cls
+    base_version_str = str(version.tag.public)
+    base_tag = version.config.version_cls(base_version_str)
+    version_for_scheme = replace(version, tag=base_tag)
 
     main_version = _entrypoints._call_version_scheme(
         version_for_scheme,

testing/test_basic_api.py

@@ -55,7 +55,9 @@ def assert_root(monkeypatch: pytest.MonkeyPatch, expected_root: str) -> None:
 
     def assertion(config: Configuration) -> ScmVersion:
         assert config.absolute_root == expected_root
-        return ScmVersion("1.0", config=config)
+        from packaging.version import Version
+
+        return ScmVersion(Version("1.0"), config=config)
 
     monkeypatch.setattr(setuptools_scm._get_version_impl, "parse_version", assertion)
 
@@ -250,6 +252,18 @@ def __init__(self, tag_str: str) -> None:
         def __repr__(self) -> str:
             return f"hello,{self.version}"
 
+        @property
+        def public(self) -> str:
+            """The public portion of the version (without local part)."""
+            return self.version.split("+")[0]
+
+        @property
+        def local(self) -> str | None:
+            """The local version segment."""
+            if "+" in self.version:
+                return self.version.split("+", 1)[1]
+            return None
+
     # you can not use normalize=False and version_cls at the same time
     with pytest.raises(
         ValueError,

testing/test_git.py

@@ -215,16 +215,26 @@ def test_version_from_git(wd: WorkDir) -> None:
         setup(use_scm_version={'normalize': False, 'write_to': 'VERSION.txt'})
         """,
     "with_created_class": """
-        from setuptools import setup
+from setuptools import setup
+
+class MyVersion:
+    def __init__(self, tag_str: str):
+        self.version = tag_str
+
+    def __repr__(self):
+        return self.version
 
-        class MyVersion:
-            def __init__(self, tag_str: str):
-                self.version = tag_str
+    @property
+    def public(self):
+        return self.version.split('+')[0]
 
-            def __repr__(self):
-                return self.version
+    @property
+    def local(self):
+        if '+' in self.version:
+            return self.version.split('+', 1)[1]
+        return None
 
-        setup(use_scm_version={'version_cls': MyVersion, 'write_to': 'VERSION.txt'})
+setup(use_scm_version={'version_cls': MyVersion, 'write_to': 'VERSION.txt'})
         """,
     "with_named_import": """
         from setuptools import setup

testing/test_integration.py

@@ -193,14 +193,16 @@ def test_pretend_version_name_takes_precedence(
     assert wd.get_version(dist_name="test") == "1.0.0"
 
 
-def test_pretend_version_accepts_bad_string(
+def test_pretend_version_rejects_invalid_string(
     monkeypatch: pytest.MonkeyPatch, wd: WorkDir
 ) -> None:
+    """Test that invalid pretend versions raise errors and bubble up."""
     monkeypatch.setenv(PRETEND_KEY, "dummy")
     wd.write("setup.py", SETUP_PY_PLAIN)
-    assert wd.get_version(write_to="test.py") == "dummy"
-    pyver = wd([sys.executable, "setup.py", "--version"])
-    assert pyver == "0.0.0"
+
+    # With strict validation, invalid pretend versions should raise errors
+    with pytest.raises(Exception, match=r".*dummy.*"):
+        wd.get_version(write_to="test.py")
 
 
 def test_pretend_metadata_with_version(

testing/test_version.py

@@ -71,7 +71,27 @@ def test_next_semver(version: ScmVersion, expected_next: str) -> None:
 
 
 def test_next_semver_bad_tag() -> None:
-    version = meta("1.0.0-foo", preformatted=True, config=c)
+    # Create a mock version class that represents an invalid version for testing error handling
+    from typing import cast
+
+    from setuptools_scm._version_cls import _VersionT
+
+    class BrokenVersionForTest:
+        """A mock version that behaves like a string but passes type checking."""
+
+        def __init__(self, version_str: str):
+            self._version_str = version_str
+
+        def __str__(self) -> str:
+            return self._version_str
+
+        def __repr__(self) -> str:
+            return f"BrokenVersionForTest({self._version_str!r})"
+
+    # Cast to the expected type to avoid type checking issues
+    broken_tag = cast(_VersionT, BrokenVersionForTest("1.0.0-foo"))
+    version = meta(broken_tag, preformatted=True, config=c)
+
     with pytest.raises(
         ValueError, match=r"1\.0\.0-foo.* can't be parsed as numeric version"
     ):
@@ -471,6 +491,18 @@ def __str__(self) -> str:
         def __repr__(self) -> str:
             return f"MyVersion<Custom{self.tag}>"
 
+        @property
+        def public(self) -> str:
+            """The public portion of the version (without local part)."""
+            return self.tag.split("+")[0]
+
+        @property
+        def local(self) -> str | None:
+            """The local version segment."""
+            if "+" in self.tag:
+                return self.tag.split("+", 1)[1]
+            return None
+
     config = Configuration(version_cls=MyVersion)  # type: ignore[arg-type]
     scm_version = meta("1.0.0-foo", config=config)