vcs-versioning 2.1.1__tar.gz → 2.2.0__tar.gz

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 <!-- towncrier release notes start -->
 
+## 2.2.0 (2026-06-24)
+
+### Added
+
+- Restore Python 3.8 and 3.9 support, re-enabling use as a build dependency for projects like scikit-build that still support these versions. ([#1445](https://github.com/pypa/setuptools-scm/issues/1445))
+
+
+### Miscellaneous
+
+- Move PKG-INFO discovery tests to setuptools-scm where the entry points are registered. ([#1446](https://github.com/pypa/setuptools-scm/issues/1446))
+
+## 2.1.2 (2026-06-23)
+
+### Fixed
+
+- Fix MetadataWorkdir crash when using custom `tag_regex` — stored tags are already parsed version strings and no longer re-parsed through the tag regex. ([#1439](https://github.com/pypa/setuptools-scm/issues/1439))
+
 ## 2.1.1 (2026-06-23)
 
 ### Fixed

{vcs_versioning-2.1.1/src/vcs_versioning.egg-info → vcs_versioning-2.2.0}/PKG-INFO

@@ -1,26 +1,28 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.1.1
+Version: 2.2.0
 Summary: the blessed package to manage your versions by vcs metadata
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
-License-Expression: MIT
+License: MIT
 Project-URL: Documentation, https://github.com/pypa/setuptools-scm#readme
 Project-URL: Issues, https://github.com/pypa/setuptools-scm/issues
 Project-URL: Source, https://github.com/pypa/setuptools-scm
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.10
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: packaging>=20
 Requires-Dist: tomli>=1; python_version < "3.11"
-Requires-Dist: typing-extensions; python_version < "3.11"
+Requires-Dist: typing-extensions>=4.1; python_version < "3.11"
 Dynamic: license-file
 
 # vcs-versioning

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/pyproject.toml

@@ -6,9 +6,9 @@
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [
-  "setuptools>=77.0.3",
+  "setuptools>=45",
   "packaging>=20",
-  'typing-extensions; python_version < "3.11"',
+  'typing-extensions>=4.1; python_version < "3.11"',
 ]
 
 [project]
@@ -17,15 +17,17 @@ description = "the blessed package to manage your versions by vcs metadata"
 readme = "README.md"
 keywords = [
 ]
-license = "MIT"
+license = {text = "MIT"}
 authors = [
   { name = "Ronny Pfannschmidt", email = "opensource@ronnypfannschmidt.de" },
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.8"
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
@@ -38,7 +40,7 @@ dynamic = [
 dependencies = [
   "packaging>=20",
   'tomli>=1; python_version < "3.11"',
-  'typing-extensions; python_version < "3.11"',
+  'typing-extensions>=4.1; python_version < "3.11"',
 ]
 
 [dependency-groups]

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_backends/_git.py

@@ -238,11 +238,15 @@ class GitWorkdir(Workdir):
         return _git_parse_inner(config, self, pre_parse=effective_pre_parse)
 
     def list_tracked_files(self, path: Path | str = "") -> list[str]:
-        """List files tracked by git, honoring export-ignore."""
+        """List files tracked by git, honoring export-ignore.
+
+        When no path is given, scopes to ``project_root`` (not the VCS root)
+        so that monorepo projects only list their own files.
+        """
         from .._file_finders import scm_find_files
         from .._file_finders._git import _git_ls_files_and_dirs
 
-        base = str(path) if path else str(self.path)
+        base = str(path) if path else str(self.project_root)
         git_files, git_dirs = _git_ls_files_and_dirs(
             str(self.path), timeout=self._subprocess_timeout
         )

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_backends/_hg.py

@@ -293,7 +293,7 @@ class HgWorkdir(Workdir):
         from .._file_finders import scm_find_files
         from .._file_finders._hg import _hg_ls_files_and_dirs
 
-        base = str(path) if path else str(self.path)
+        base = str(path) if path else str(self.project_root)
         hg_files, hg_dirs = _hg_ls_files_and_dirs(
             str(self.path),
             hg_command=self._hg_command,

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_backends/_hg_git.py

@@ -95,7 +95,7 @@ class GitWorkdirHgClient(GitWorkdir, HgWorkdir):
         from .._file_finders import scm_find_files
         from .._file_finders._hg import _hg_ls_files_and_dirs
 
-        base = str(path) if path else str(self.path)
+        base = str(path) if path else str(self.project_root)
         hg_files, hg_dirs = _hg_ls_files_and_dirs(
             str(self.path),
             hg_command=self._hg_command,

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_backends/_jj.py

@@ -263,7 +263,7 @@ class JjWorkdir(Workdir):
         from .._file_finders import scm_find_files
         from .._file_finders._jj import _jj_ls_files_and_dirs
 
-        base = str(path) if path else str(self.path)
+        base = str(path) if path else str(self.project_root)
         jj_files, jj_dirs = _jj_ls_files_and_dirs(
             str(self.path), timeout=self._subprocess_timeout
         )

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_backends/_scm_workdir.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from dataclasses import field as dc_field
 from datetime import date, datetime, timezone
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, overload
 
 from .._scm_version import ScmVersion
 
@@ -16,6 +16,37 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+class _ProjectRootDescriptor:
+    """Descriptor for ``project_root`` that defaults to ``path``.
+
+    Acts as default when no value has been set on the instance.
+    Stores explicitly assigned values in the instance ``__dict__``.
+    """
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self._name = name
+
+    @overload
+    def __get__(self, obj: None, objtype: type) -> _ProjectRootDescriptor: ...
+
+    @overload
+    def __get__(self, obj: ScmWorkdir, objtype: type | None = None) -> Path: ...
+
+    def __get__(
+        self, obj: ScmWorkdir | None, objtype: type | None = None
+    ) -> Path | _ProjectRootDescriptor:
+        if obj is None:
+            return self
+        value: Path | None = obj.__dict__.get(self._name)
+        if value is None:
+            return obj.path
+        return value
+
+    def __set__(self, obj: ScmWorkdir, value: Path | None) -> None:
+        if isinstance(value, Path):
+            obj.__dict__[self._name] = value
+
+
 def get_latest_file_mtime(changed_files: list[str], base_path: Path) -> date | None:
     """Get the latest modification time of the given files.
 
@@ -61,15 +92,11 @@ class ScmWorkdir:
     """
 
     path: Path
-    project_root: Path | None = dc_field(default=None)
+    project_root: Path = _ProjectRootDescriptor()  # type: ignore[assignment]
 
     _config: Configuration | None = dc_field(default=None, repr=False, compare=False)
     """Back-reference to the ``Configuration`` that discovered this workdir."""
 
-    def __post_init__(self) -> None:
-        if self.project_root is None:
-            self.project_root = self.path
-
     @property
     def _subprocess_timeout(self) -> int | None:
         """Subprocess timeout from ``config.env``.
@@ -95,7 +122,6 @@ class ScmWorkdir:
     @property
     def project_path(self) -> str:
         """Discovered relative path from VCS root to project directory."""
-        assert self.project_root is not None
         if self.path == self.project_root:
             return ""
         from .._paths import relative_project_path

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_cli/__init__.py

@@ -4,7 +4,11 @@ import json
 import os
 import sys
 from collections.abc import Iterable
-from importlib.resources import files
+
+if sys.version_info >= (3, 9):
+    from importlib.resources import files
+else:
+    from importlib.resources import read_text as _read_text
 from pathlib import Path
 from typing import TypedDict
 
@@ -182,7 +186,10 @@ def _create_archival_file(opts: CliNamespace, config: Configuration) -> int:
     assert opts.archival_template is not None
 
     # Load template content from package resources
-    content = files(__package__).joinpath(opts.archival_template).read_text("utf-8")
+    if sys.version_info >= (3, 9):
+        content = files(__package__).joinpath(opts.archival_template).read_text("utf-8")
+    else:
+        content = _read_text(__package__, opts.archival_template, encoding="utf-8")
 
     # Print appropriate message based on template
     if opts.archival_template == "git_archival_stable.txt":

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_compat.py

@@ -3,10 +3,38 @@
 from __future__ import annotations
 
 import os
-from typing import TypeAlias
-
-# Path type for accepting both strings and PathLike objects
-PathT: TypeAlias = os.PathLike[str] | str
+import sys
+from importlib.metadata import entry_points as _stdlib_entry_points
+from typing import TYPE_CHECKING, Union
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+if TYPE_CHECKING:
+    from importlib.metadata import EntryPoint
+
+    PathT: TypeAlias = os.PathLike[str] | str
+else:
+    PathT: TypeAlias = Union[os.PathLike, str]
+
+
+if sys.version_info >= (3, 10):
+    from importlib.metadata import entry_points as entry_points
+else:
+
+    def entry_points(
+        **params: str,
+    ) -> list[EntryPoint]:
+        """Backport of entry_points(group=...) for Python 3.8/3.9."""
+        groups = _stdlib_entry_points()
+        group = params.get("group", "")
+        name = params.get("name")
+        eps = list(groups.get(group, []))  # type: ignore[call-overload]
+        if name is not None:
+            eps = [ep for ep in eps if ep.name == name]
+        return eps
 
 
 def normalize_path_for_assertion(path: str) -> str:

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_entrypoints.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import logging
 from collections.abc import Callable, Iterator
 from importlib import metadata as im
-from importlib.metadata import entry_points
 from typing import TYPE_CHECKING, Any, cast
 
+from ._compat import entry_points
+
 __all__ = [
     "entry_points",
     "im",
@@ -65,7 +66,7 @@ def _iter_version_schemes(
             or _get_from_object_reference_str(scheme_value, entrypoint),
         )
 
-    if isinstance(scheme_value, list | tuple):
+    if isinstance(scheme_value, (list, tuple)):
         for variant in scheme_value:
             if variant not in _memo:
                 _memo.add(variant)

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_fallback_workdir.py

@@ -34,6 +34,11 @@ class FallbackWorkdir:
     _config: Configuration | None = dc_field(default=None, repr=False, compare=False)
     """Back-reference to the ``Configuration`` that discovered this workdir."""
 
+    @property
+    def project_root(self) -> Path:
+        """Fallback workdirs always live at the project root."""
+        return self.path
+
     @property
     def config(self) -> Configuration:
         if self._config is None:
@@ -76,8 +81,20 @@ class MetadataWorkdir(FallbackWorkdir):
                     data.node_date,
                     self.metadata_dir,
                 )
+        # The tag in scm_version.json is already a parsed version string
+        # (e.g. "1.5.5"), not a raw VCS tag (e.g. "cuda-pathfinder-v1.5.5").
+        # Convert to version_cls so _parse_tag skips tag_regex matching.
+        try:
+            tag = self.config.version_cls(data.tag)
+        except Exception:
+            log.warning(
+                "cannot parse stored tag %r in metadata at %s",
+                data.tag,
+                self.metadata_dir,
+            )
+            return None
         return meta(
-            tag=data.tag,
+            tag=tag,
             distance=data.distance,
             node=data.node,
             dirty=data.dirty,

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_file_finders/__init__.py

@@ -2,8 +2,13 @@ from __future__ import annotations
 
 import logging
 import os
+import sys
 from collections.abc import Callable, Mapping
-from typing import TypeGuard
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
 
 from .. import _types as _t
 from .._compat import norm_real

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_file_finders/_git.py

@@ -85,6 +85,9 @@ def _git_ls_files_and_dirs(
         log.error("listing git files failed - pretending there aren't any")
         return set(), set()
 
+    # Normalize toplevel to match what scm_find_files expects:
+    # absolute, symlinks resolved, case-normalized (normcase).
+    toplevel = norm_real(toplevel)
     git_files: set[str] = set()
     git_dirs: set[str] = {toplevel}
     for name in res.stdout.rstrip("\0").split("\0"):

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_get_version_impl.py

@@ -90,7 +90,7 @@ def _resolve_version(config: Configuration) -> ScmVersion | None:
     return None
 
 
-def _warn_if_tracked(target: Path, root: Path) -> None:
+def _warn_if_tracked(target: Path, root: Path, config: Configuration) -> None:
     """Warn when *target* is tracked in version control (#468).
 
     Writing a version file that is tracked makes ``git describe --dirty``
@@ -101,7 +101,7 @@ def _warn_if_tracked(target: Path, root: Path) -> None:
 
     for workdir_cls in (GitWorkdir, HgWorkdir):
         try:
-            wd = workdir_cls.from_potential_worktree(root)
+            wd = workdir_cls.from_potential_worktree(root, config)
         except Exception:
             continue
         if wd is not None and wd.is_file_tracked(target):
@@ -125,7 +125,7 @@ def write_version_files(
 
         write_to = Path(config.write_to)
         target = root / write_to if not write_to.is_absolute() else write_to
-        _warn_if_tracked(target, root)
+        _warn_if_tracked(target, root, config)
 
         dump_version(
             root=config.root,
@@ -142,7 +142,7 @@ def write_version_files(
         # todo: use a better name than fallback root
         assert config.relative_to is not None
         target = Path(config.relative_to).parent.joinpath(version_file)
-        _warn_if_tracked(target, root)
+        _warn_if_tracked(target, root, config)
 
         write_version_to_path(
             target,

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_legacy_parse.py

@@ -13,8 +13,6 @@ from __future__ import annotations
 
 import logging
 import warnings
-from dataclasses import dataclass
-from dataclasses import field as dc_field
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -29,7 +27,6 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
-@dataclass()
 class LegacyParseWorkdir(ScmWorkdir):
     """Wraps a legacy ``config.parse`` callable as a workdir.
 
@@ -38,12 +35,17 @@ class LegacyParseWorkdir(ScmWorkdir):
     entry-point group.
     """
 
-    _parse_fn: ParseFunction | None = dc_field(default=None, repr=False)
+    parse_fn: ParseFunction
 
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        if self._parse_fn is None:
-            raise TypeError("LegacyParseWorkdir requires a _parse_fn")
+    def __init__(
+        self,
+        path: Path,
+        *,
+        parse_fn: ParseFunction,
+        _config: Configuration | None = None,
+    ) -> None:
+        super().__init__(path=path, _config=_config)
+        self.parse_fn = parse_fn
 
     def get_scm_version(self) -> ScmVersion | None:
         warnings.warn(
@@ -53,8 +55,7 @@ class LegacyParseWorkdir(ScmWorkdir):
             DeprecationWarning,
             stacklevel=2,
         )
-        assert self._parse_fn is not None
-        result = self._parse_fn(self.config.absolute_root, config=self.config)
+        result = self.parse_fn(self.config.absolute_root, config=self.config)
         if result is not None and not isinstance(result, ScmVersion):
             raise TypeError(
                 f"version parse result was {result!r}\n"

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_overrides.py

@@ -207,15 +207,25 @@ def _apply_metadata_overrides(
 
     log.info("Applying metadata overrides: %s", metadata_overrides)
 
-    # Get type hints from PretendMetadataDict for validation
-    field_types = get_type_hints(PretendMetadataDict)
+    # Get valid field names from PretendMetadataDict for validation.
+    # Use __annotations__ keys directly instead of get_type_hints() to avoid
+    # evaluating PEP 604 forward references on Python <3.10.
+    valid_fields = frozenset(PretendMetadataDict.__annotations__)
+
+    # Try to resolve actual types for runtime validation (best-effort)
+    try:
+        field_types: dict[str, Any] | None = get_type_hints(PretendMetadataDict)
+    except TypeError:
+        field_types = None
 
     # Apply each override individually using dataclasses.replace
     result = scm_version
 
     for field, value in metadata_overrides.items():
-        # Validate field types using the TypedDict annotations
-        if field in field_types:
+        if field not in valid_fields:
+            continue
+        # Runtime type validation (only when type hints are resolvable)
+        if field_types is not None and field in field_types:
             expected_type = field_types[field]
             # Handle Optional/Union types (e.g., str | None)
             if hasattr(expected_type, "__args__"):

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_protocols.py

@@ -32,6 +32,16 @@ class WorkdirProtocol(Protocol):
     @property
     def path(self) -> Path: ...
 
+    @property
+    def project_root(self) -> Path:
+        """The project directory (where pyproject.toml lives).
+
+        For SCM workdirs this may differ from ``path`` (the VCS root).
+        For fallback workdirs this is always equal to ``path``.
+        Guaranteed non-None after construction.
+        """
+        ...
+
     def get_scm_version(self) -> ScmVersion | None:
         """Raw version metadata before overrides / formatting."""
         ...
@@ -49,9 +59,6 @@ class WorkdirProtocol(Protocol):
 class ScmWorkdirProtocol(WorkdirProtocol, Protocol):
     """Live VCS checkout: adds monorepo / nested-project fields."""
 
-    @property
-    def project_root(self) -> Path: ...
-
     @property
     def project_path(self) -> str:
         """POSIX relative path from VCS root to project_root (empty when equal)."""

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_pyproject_reading.py

@@ -9,7 +9,11 @@ import warnings
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TypeAlias
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -158,7 +162,7 @@ class PyProjectData:
 
 # Testing injection type for configuration reading
 GivenPyProjectResult: TypeAlias = (
-    PyProjectData | InvalidTomlError | FileNotFoundError | None
+    "PyProjectData | InvalidTomlError | FileNotFoundError | None"
 )
 
 
@@ -201,7 +205,7 @@ def read_pyproject(
     if _given_result is not None:
         if isinstance(_given_result, PyProjectData):
             return _given_result
-        if isinstance(_given_result, InvalidTomlError | FileNotFoundError):
+        if isinstance(_given_result, (InvalidTomlError, FileNotFoundError)):
             raise _given_result
 
     if _given_definition is not None:

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_run_cmd.py

@@ -4,6 +4,7 @@ import logging
 import os
 import shlex
 import subprocess
+import sys
 import textwrap
 import warnings
 from collections.abc import Callable, Mapping, Sequence
@@ -35,8 +36,13 @@ def _get_timeout(env: Mapping[str, str]) -> int:
 PARSE_RESULT = TypeVar("PARSE_RESULT")
 T = TypeVar("T")
 
+if sys.version_info >= (3, 9):
+    _CompletedProcessBase = subprocess.CompletedProcess[str]
+else:
+    _CompletedProcessBase = subprocess.CompletedProcess
 
-class CompletedProcess(subprocess.CompletedProcess[str]):
+
+class CompletedProcess(_CompletedProcessBase):
     @classmethod
     def from_raw(
         cls, input: subprocess.CompletedProcess[str], strip: bool = True

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_scm_metadata.py

@@ -99,13 +99,14 @@ def scm_version_data_from_scm_version(
     scm_version: ScmVersion | VersionFields,
 ) -> ScmVersionData:
     """Build ``ScmVersionData`` from a live ``ScmVersion`` object."""
-    match scm_version.node_date:
-        case date() as d:
-            node_date_str: str | None = d.isoformat()
-        case str() as s:
-            node_date_str = s
-        case _:
-            node_date_str = None
+    node_date = scm_version.node_date
+    node_date_str: str | None
+    if isinstance(node_date, date):
+        node_date_str = node_date.isoformat()
+    elif isinstance(node_date, str):
+        node_date_str = node_date
+    else:
+        node_date_str = None
     return ScmVersionData(
         tag=str(scm_version.tag),
         distance=scm_version.distance,

{vcs_versioning-2.1.1 → vcs_versioning-2.2.0}/src/vcs_versioning/_scm_version.py

@@ -9,10 +9,16 @@ from __future__ import annotations
 
 import dataclasses
 import logging
+import sys
 import warnings
 from collections.abc import Callable
 from datetime import date, datetime
-from typing import TYPE_CHECKING, Any, Concatenate, ParamSpec, TypedDict
+from typing import TYPE_CHECKING, Any, TypedDict
+
+if sys.version_info >= (3, 10):
+    from typing import Concatenate, ParamSpec
+else:
+    from typing_extensions import Concatenate, ParamSpec
 
 from . import _config
 from . import _version_cls as _v
@@ -20,8 +26,6 @@ from ._node_utils import _format_node_for_output
 from ._version_cls import _Version
 
 if TYPE_CHECKING:
-    import sys
-
     if sys.version_info >= (3, 11):
         from typing import Unpack
     else:
@@ -347,20 +351,14 @@ class ScmVersion:
 
 def _parse_tag(
     tag: _Version | str, preformatted: bool, config: _config.Configuration
-) -> _Version:
+) -> _Version | None:
     if preformatted:
-        # 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
-        return version
+        return tag_to_version(tag, config)
     else:
         return tag
 
@@ -389,18 +387,20 @@ def meta(
     node_date: date | None = None,
     time: datetime | None = None,
 ) -> ScmVersion:
-    parsed_version: _Version
-    # Enhanced string validation for preformatted versions
+    parsed_version: _Version | None
     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)
 
+    if parsed_version is None:
+        raise ValueError(
+            f"Can't parse version from tag {tag!r}"
+            f" (tag_regex={config.tag.regex.pattern!r},"
+            f" tag_prefix={config.tag.prefix!r})"
+        )
+
     log.info("version %s -> %s", tag, parsed_version)
-    assert parsed_version is not None, f"Can't parse version {tag}"
 
     kwargs: _ScmVersionKwargs = {
         "distance": distance,