vcs-versioning 2.1.2__tar.gz → 2.2.1__tar.gz

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/CHANGELOG.md

@@ -2,11 +2,31 @@
 
 <!-- towncrier release notes start -->
 
+## 2.2.1 (2026-06-29)
+
+### Fixed
+
+- Fix crash in `_warn_if_tracked` when the version file target is a relative path
+  by resolving it against the project root before comparison.
+  Also warn (instead of crashing) when the target resolves outside the project root. ([#1451](https://github.com/pypa/setuptools-scm/issues/1451))
+
+## 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))
+- Scope `list_tracked_files` to `project_root` in monorepo setups so that sdists no longer include files from sibling projects when `root=".."` is configured. ([#1440](https://github.com/pypa/setuptools-scm/issues/1440))
 
 ## 2.1.1 (2026-06-23)
 

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/MANIFEST.in

@@ -9,5 +9,6 @@ include *.toml
 include LICENSE.txt
 include README.md
 include CHANGELOG.md
+include uv.lock
 
 prune .cursor

{vcs_versioning-2.1.2/src/vcs_versioning.egg-info → vcs_versioning-2.2.1}/PKG-INFO

@@ -1,26 +1,28 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.1.2
+Version: 2.2.1
 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.2 → vcs_versioning-2.2.1}/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,13 +40,12 @@ 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]
 test = [
   "pytest",
-  "pytest-cov",
   "pytest-xdist",
 ]
 
@@ -103,27 +104,29 @@ tag_regex = "^vcs-versioning-(?P<version>v?\\d+(?:\\.\\d+){0,2}[^\\+]*)(?:\\+.*)
 fallback_version = "0.1.0"
 scm.git.describe_command = ["git", "describe", "--dirty", "--tags", "--long", "--match", "vcs-versioning-*"]
 
-[tool.coverage.run]
-branch = true
-parallel = true
-omit = [
-  "vcs_versioning/__about__.py",
-]
-
-[tool.coverage.report]
-exclude_lines = [
-  "no cov",
-  "if __name__ == .__main__.:",
-  "if TYPE_CHECKING:",
-]
-
 [tool.pytest.ini_options]
+minversion = "8.2"
 testpaths = ["testing_vcs"]
 python_files = ["test_*.py"]
-addopts = ["-ra", "--strict-markers", "-p", "vcs_versioning.test_api"]
+xfail_strict = true
+addopts = ["-ra", "--strict-config", "--strict-markers", "-p", "vcs_versioning.test_api"]
+timeout = 300
+filterwarnings = [
+  "error",
+  "ignore:.*tool\\.setuptools_scm.*",
+  "ignore:.*git archive did not support describe output.*:UserWarning",
+  "ignore:.*unprocessed git archival found.*:UserWarning",
+  "ignore:.*without VcsEnvironment.*:DeprecationWarning",
+  "ignore:.*Passing config to workdir.*:DeprecationWarning",
+  "ignore:.*tag_regex.*is deprecated.*:DeprecationWarning",
+  "ignore:.*write_to_source.*:DeprecationWarning",
+  "ignore:.*relative_to is expected to be a file.*:UserWarning",
+]
+log_level = "debug"
+log_cli_level = "info"
 markers = [
-  "issue: marks tests related to specific issues",
-  "no_init: use setup_hg(init=False) for wd fixture - hg check without worktree",
+  "issue(id): reference to github issue",
+  "no_init: skip initializing the VCS repository in the test fixture",
   "skip_commit: allows to skip committing in the helpers",
 ]
 

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_backends/_hg.py

@@ -22,9 +22,6 @@ log = logging.getLogger(__name__)
 _HG_PSEUDO_TAGS = frozenset({"tip", "qbase", "qtip", "qparent"})
 
 
-_DEFAULT_HG_COMMAND = "hg"
-
-
 def _get_hg_command() -> str:
     """Read the hg command from resolved runtime settings.
 

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/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.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_compat.py

@@ -3,10 +3,38 @@
 from __future__ import annotations
 
 import os
-from typing import TypeAlias
+import sys
+from importlib.metadata import entry_points as _stdlib_entry_points
+from typing import TYPE_CHECKING, Union
 
-# Path type for accepting both strings and PathLike objects
-PathT: TypeAlias = os.PathLike[str] | str
+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:
@@ -58,19 +86,6 @@ def strip_path_suffix(
     return full_path[: -len(suffix_path)]
 
 
-# Legacy aliases for backward compatibility during transition
-def assert_path_endswith(
-    full_path: str, suffix_path: str, error_msg: str | None = None
-) -> None:
-    """Legacy alias - use strip_path_suffix instead."""
-    strip_path_suffix(full_path, suffix_path, error_msg)
-
-
-def compute_path_prefix(full_path: str, suffix_path: str) -> str:
-    """Legacy alias - use strip_path_suffix instead."""
-    return strip_path_suffix(full_path, suffix_path)
-
-
 def norm_real(path: PathT) -> str:
     """Normalize and resolve a path (combining normcase and realpath).
 

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_config.py

@@ -203,9 +203,6 @@ class TagConfiguration:
         return cls(**tag_data)
 
 
-_SENTINEL_TAG_CONFIG = TagConfiguration()
-
-
 class _TagRegexDescriptor:
     """Data descriptor for deprecated top-level tag_regex field.
 

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/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.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_file_finders/__init__.py

@@ -2,8 +2,13 @@ from __future__ import annotations
 
 import logging
 import os
-from collections.abc import Callable, Mapping
-from typing import TypeGuard
+import sys
+from collections.abc import Callable, Iterable, Mapping
+
+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
@@ -135,4 +140,35 @@ def find_files(path: _t.PathT = "") -> list[str]:
     return []
 
 
-__all__ = ["scm_find_files", "is_toplevel_acceptable", "find_files"]
+def collect_files_and_dirs(
+    raw_names: Iterable[str], toplevel: str
+) -> tuple[set[str], set[str]]:
+    """Normalize VCS file listings into absolute ``(files, dirs)`` sets.
+
+    Each backend produces a list of relative paths from its own command
+    (``git ls-files``, ``hg files``, ``jj file list``).  This helper
+    normalizes case and separators, joins with *toplevel*, and collects
+    the directory ancestry — the same loop that was previously duplicated
+    in every backend.
+    """
+    files: set[str] = set()
+    dirs: set[str] = {toplevel}
+    for name in raw_names:
+        if not name:
+            continue
+        name = os.path.normcase(name).replace("/", os.path.sep)
+        fullname = os.path.join(toplevel, name)
+        files.add(fullname)
+        dirname = os.path.dirname(fullname)
+        while len(dirname) > len(toplevel) and dirname not in dirs:
+            dirs.add(dirname)
+            dirname = os.path.dirname(dirname)
+    return files, dirs
+
+
+__all__ = [
+    "scm_find_files",
+    "is_toplevel_acceptable",
+    "find_files",
+    "collect_files_and_dirs",
+]

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_file_finders/_git.py

@@ -10,7 +10,7 @@ from .._backends._git import run_git
 from .._compat import norm_real, strip_path_suffix
 from .._integration import data_from_mime
 from .._run_cmd import run as _run
-from . import is_toplevel_acceptable, scm_find_files
+from . import collect_files_and_dirs, is_toplevel_acceptable, scm_find_files
 
 log = logging.getLogger(__name__)
 
@@ -85,22 +85,8 @@ 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"):
-        if not name:
-            continue
-        name = os.path.normcase(name).replace("/", os.path.sep)
-        fullname = os.path.join(toplevel, name)
-        git_files.add(fullname)
-        dirname = os.path.dirname(fullname)
-        while len(dirname) > len(toplevel) and dirname not in git_dirs:
-            git_dirs.add(dirname)
-            dirname = os.path.dirname(dirname)
-    return git_files, git_dirs
+    return collect_files_and_dirs(res.stdout.rstrip("\0").split("\0"), toplevel)
 
 
 def git_find_files(path: _t.PathT = "") -> list[str]:

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_file_finders/_hg.py

@@ -8,7 +8,7 @@ from .. import _types as _t
 from .._backends._hg import run_hg
 from .._compat import norm_real
 from .._integration import data_from_mime
-from . import is_toplevel_acceptable, scm_find_files
+from . import collect_files_and_dirs, is_toplevel_acceptable, scm_find_files
 
 log = logging.getLogger(__name__)
 
@@ -34,20 +34,10 @@ def _hg_ls_files_and_dirs(
     hg_command: str | None = None,
     timeout: int | None = None,
 ) -> tuple[set[str], set[str]]:
-    hg_files: set[str] = set()
-    hg_dirs = {toplevel}
     res = run_hg(["files"], cwd=toplevel, hg_command=hg_command, timeout=timeout)
     if res.returncode:
         return set(), set()
-    for name in res.stdout.splitlines():
-        name = os.path.normcase(name).replace("/", os.path.sep)
-        fullname = os.path.join(toplevel, name)
-        hg_files.add(fullname)
-        dirname = os.path.dirname(fullname)
-        while len(dirname) > len(toplevel) and dirname not in hg_dirs:
-            hg_dirs.add(dirname)
-            dirname = os.path.dirname(dirname)
-    return hg_files, hg_dirs
+    return collect_files_and_dirs(res.stdout.splitlines(), toplevel)
 
 
 def hg_find_files(path: str = "") -> list[str]:

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_file_finders/_jj.py

@@ -13,7 +13,7 @@ import subprocess
 from .. import _types as _t
 from .._compat import norm_real
 from .._run_cmd import run as _run
-from . import is_toplevel_acceptable, scm_find_files
+from . import collect_files_and_dirs, is_toplevel_acceptable, scm_find_files
 
 log = logging.getLogger(__name__)
 
@@ -51,19 +51,7 @@ def _jj_ls_files_and_dirs(
         log.error("listing jj files failed - pretending there aren't any")
         return set(), set()
 
-    jj_files: set[str] = set()
-    jj_dirs: set[str] = {toplevel}
-    for name in res.stdout.strip().split("\n"):
-        if not name:
-            continue
-        name = os.path.normcase(name).replace("/", os.path.sep)
-        fullname = os.path.join(toplevel, name)
-        jj_files.add(fullname)
-        dirname = os.path.dirname(fullname)
-        while len(dirname) > len(toplevel) and dirname not in jj_dirs:
-            jj_dirs.add(dirname)
-            dirname = os.path.dirname(dirname)
-    return jj_files, jj_dirs
+    return collect_files_and_dirs(res.stdout.strip().split("\n"), toplevel)
 
 
 def jj_find_files(path: _t.PathT = "") -> list[str]:

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_get_version_impl.py

@@ -6,13 +6,18 @@ import re
 import warnings
 from pathlib import Path
 from re import Pattern
-from typing import Any, NoReturn
+from typing import TYPE_CHECKING, Any, NoReturn
 
 from . import _config
 from . import _types as _t
 from ._config import Configuration, TagConfiguration
 from ._environment import resolve_runtime_env
 
+if TYPE_CHECKING:
+    from ._config import ParseFunction
+    from ._environment import VcsEnvironment
+    from ._version_cls import Version as _VersionType
+
 # Backward-compat re-export used by vcs-versioning/setup.py
 from ._legacy_parse import (
     resolved_fallback_root as resolved_fallback_root,  # noqa: F401
@@ -90,15 +95,31 @@ def _resolve_version(config: Configuration) -> ScmVersion | None:
     return None
 
 
-def _warn_if_tracked(target: Path, root: Path, config: Configuration) -> None:
+def _warn_if_tracked(target: Path, root: Path, config: Configuration) -> bool:
     """Warn when *target* is tracked in version control (#468).
 
     Writing a version file that is tracked makes ``git describe --dirty``
     report a dirty tree on tag checkouts, causing wrong version numbers.
+
+    Returns False if target resolves outside root (caller should skip the write).
     """
     from ._backends._git import GitWorkdir
     from ._backends._hg import HgWorkdir
 
+    if not target.is_absolute():
+        target = root / target
+    resolved_target = target.resolve()
+    resolved_root = root.resolve()
+    try:
+        resolved_target.relative_to(resolved_root)
+    except ValueError:
+        # todo: emit as GitHub Actions warning via ::warning:: syntax
+        warnings.warn(
+            f"version file target {target} resolves outside of the project root {root}",
+            stacklevel=2,
+        )
+        return False
+
     for workdir_cls in (GitWorkdir, HgWorkdir):
         try:
             wd = workdir_cls.from_potential_worktree(root, config)
@@ -113,7 +134,8 @@ def _warn_if_tracked(target: Path, root: Path, config: Configuration) -> None:
                 " See https://github.com/pypa/setuptools-scm/issues/468",
                 stacklevel=3,
             )
-            return
+            return True
+    return True
 
 
 def write_version_files(
@@ -125,7 +147,8 @@ 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, config)
+        if not _warn_if_tracked(target, root, config):
+            return
 
         dump_version(
             root=config.root,
@@ -142,7 +165,8 @@ 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, config)
+        if not _warn_if_tracked(target, root, config):
+            return
 
         write_version_to_path(
             target,
@@ -252,14 +276,14 @@ def get_version(
     parentdir_prefix_version: str | None = None,
     fallback_version: str | None = None,
     fallback_root: _t.PathT = ".",
-    parse: Any | None = None,
+    parse: ParseFunction | None = None,
     git_describe_command: _t.CMD_TYPE | None = None,
     dist_name: str | None = None,
-    version_cls: Any | None = None,
+    version_cls: type[_VersionType] | str | None = None,
     normalize: bool = True,
     search_parent_directories: bool = False,
     scm: dict[str, Any] | None = None,
-    _env: Any | None = None,
+    _env: VcsEnvironment | None = None,
 ) -> str:
     """
     If supplied, relative_to should be a file from which root may

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/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,7 +35,17 @@ class LegacyParseWorkdir(ScmWorkdir):
     entry-point group.
     """
 
-    parse_fn: ParseFunction = dc_field(repr=False, kw_only=True)
+    parse_fn: ParseFunction
+
+    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(

{vcs_versioning-2.1.2 → vcs_versioning-2.2.1}/src/vcs_versioning/_overrides.py

@@ -19,7 +19,7 @@ from packaging.utils import canonicalize_name
 
 from . import _config
 from . import _types as _t
-from ._scm_version import ScmVersion, meta  # noqa: F401 - for type checking
+from ._scm_version import ScmVersion, meta
 from ._version_cls import Version as _Version
 
 log = logging.getLogger(__name__)
@@ -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.2 → vcs_versioning-2.2.1}/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: