vcs-versioning 2.0.1__tar.gz → 2.1.0__tar.gz

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!-- towncrier release notes start -->
 
+## 2.1.0 (2026-06-22)
+
+### Added
+
+- Add `VcsEnvironment.build_config_from_pyproject`, `build_config_from_data`, and `pyproject_tool_names` methods for canonical env-first configuration creation. ([#1424](https://github.com/pypa/setuptools-scm/issues/1424))
+
+
+### Fixed
+
+- Fix DeprecationWarning leak in pretend API by ensuring all public APIs attach VcsEnvironment to Configuration before accessing env-dependent properties. ([#1424](https://github.com/pypa/setuptools-scm/issues/1424))
+- Fix fallback discovery so an unprocessed `.git_archival.txt` no longer shadows a valid `PKG-INFO` in PyPI sdists. ([#1431](https://github.com/pypa/setuptools-scm/issues/1431))
+
 ## 2.0.1 (2026-06-22)
 
 ### Fixed

{vcs_versioning-2.0.1/src/vcs_versioning.egg-info → vcs_versioning-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.0.1
+Version: 2.1.0
 Summary: the blessed package to manage your versions by vcs metadata
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
 License-Expression: MIT

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/__init__.py

@@ -25,6 +25,7 @@ def build_configuration_from_pyproject(
     pyproject_data: PyProjectData,
     *,
     dist_name: str | None = None,
+    env: VcsEnvironment | None = None,
     **integrator_overrides: Any,
 ) -> Configuration:
     """Build Configuration from PyProjectData with full workflow.
@@ -36,7 +37,7 @@ def build_configuration_from_pyproject(
     2. Determine dist_name (argument > pyproject.project_name)
     3. Apply integrator overrides (override config file)
     4. Apply environment TOML overrides (highest priority)
-    5. Create and validate Configuration instance
+    5. Create and validate Configuration instance with VcsEnvironment attached
 
     Integrators create PyProjectData themselves:
 
@@ -73,6 +74,8 @@ def build_configuration_from_pyproject(
     Args:
         pyproject_data: Parsed pyproject data (integrator creates this)
         dist_name: Distribution name (overrides pyproject_data.project_name)
+        env: Optional VcsEnvironment. If None, resolves from the active
+             GlobalOverrides context or process environment.
         **integrator_overrides: Integrator-provided config overrides
                                (override config file, but overridden by env)
 
@@ -88,9 +91,12 @@ def build_configuration_from_pyproject(
     This allows integrators to provide their own transformations
     while still respecting user environment variable overrides.
     """
-    from ._integrator_helpers import build_configuration_from_pyproject_internal
+    from ._environment import resolve_runtime_env
 
-    return build_configuration_from_pyproject_internal(
+    if env is None:
+        env = resolve_runtime_env()
+
+    return env.build_config_from_pyproject(
         pyproject_data=pyproject_data,
         dist_name=dist_name,
         **integrator_overrides,

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_config.py

@@ -347,27 +347,19 @@ class Configuration:
                     self.tag, regex=_check_tag_regex(tag_regex)
                 )
 
+        # TODO(#1429): re-introduce these warnings with non-conflicting logic
         if self.tag.strict is None:
-            warnings.warn(
-                "tag.strict is not set. Currently defaults to False (permissive "
-                "tag matching). In a future major version the default will change "
-                "to True (require tags to contain a dot). "
-                "Set tag.strict = true or tag.strict = false explicitly in your "
-                "[tool.setuptools_scm] / [tool.vcs-versioning] config to silence "
-                "this warning.",
-                FutureWarning,
-                stacklevel=2,
+            log.debug(
+                "tag.strict is not set — defaults to False (permissive tag matching)"
             )
 
         if (
             self.tag.prefix or self.tag.strict is not None
         ) and self.scm.git.describe_command is not None:
-            warnings.warn(
+            log.debug(
                 "Both tag.prefix/tag.strict and scm.git.describe_command are set. "
                 "The explicit describe_command takes precedence; tag.prefix and "
-                "tag.strict will have no effect on the git describe match pattern.",
-                UserWarning,
-                stacklevel=2,
+                "tag.strict will have no effect on the git describe match pattern."
             )
 
         self._resolved_paths = resolve_paths(
@@ -450,6 +442,7 @@ class Configuration:
         *,
         tool_names: tuple[str, ...] | None = None,
         env: Mapping[str, str] | None = None,
+        _env: VcsEnvironment | None = None,
         **kwargs: Any,
     ) -> Configuration:
         """
@@ -462,6 +455,7 @@ class Configuration:
         - dist_name: name of the distribution
         - tool_names: env-var prefix order for TOML overrides
         - env: environment mapping for TOML overrides (default: os.environ)
+        - _env: VcsEnvironment to attach to the resulting Configuration
         - **kwargs: additional keyword arguments to pass to the Configuration constructor
         """
 
@@ -485,14 +479,20 @@ class Configuration:
         args.update(project_overrides)
 
         # Env overrides: highest priority
-        args.update(
-            read_toml_overrides(args["dist_name"], tool_names=tool_names, env=env)
-        )
-        return cls.from_data(relative_to=relative_to, data=args)
+        if _env is not None:
+            args.update(_env.read_toml_overrides(args["dist_name"]))
+        else:
+            args.update(
+                read_toml_overrides(args["dist_name"], tool_names=tool_names, env=env)
+            )
+        return cls.from_data(relative_to=relative_to, data=args, _env=_env)
 
     @classmethod
     def from_data(
-        cls, relative_to: str | os.PathLike[str], data: dict[str, Any]
+        cls,
+        relative_to: str | os.PathLike[str],
+        data: dict[str, Any],
+        _env: VcsEnvironment | None = None,
     ) -> Configuration:
         """
         given configuration data
@@ -526,6 +526,7 @@ class Configuration:
             version_cls=version_cls,
             tag=tag_config,
             scm=scm_config,
+            _env=_env,
             **data,
         )
 

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_environment.py

@@ -22,7 +22,7 @@ from typing import TYPE_CHECKING, Any, Literal
 if TYPE_CHECKING:
     from pytest import MonkeyPatch
 
-    from . import _config, overrides
+    from . import _config, _overrides, overrides
 
 log = logging.getLogger(__name__)
 
@@ -248,7 +248,86 @@ class VcsEnvironment:
         from ._config import Configuration
 
         config = Configuration.from_file(
-            tool_names=self.tool_names, env=self._env, **kwargs
+            tool_names=self.tool_names, env=self._env, _env=self, **kwargs
         )
-        object.__setattr__(config, "_env", self)
         return config
+
+    def build_config_from_data(
+        self,
+        relative_to: str | os.PathLike[str],
+        data: dict[str, Any],
+    ) -> _config.Configuration:
+        """Create a ``Configuration`` from pre-assembled data dict.
+
+        Use this when you have already extracted and merged configuration
+        data (e.g. from pyproject section + overrides) and want to build
+        a validated Configuration without re-reading files.
+        """
+        from ._config import Configuration
+
+        return Configuration.from_data(relative_to=relative_to, data=data, _env=self)
+
+    def build_config_from_pyproject(
+        self,
+        pyproject_data: Any,
+        *,
+        dist_name: str | None = None,
+        **integrator_overrides: Any,
+    ) -> _config.Configuration:
+        """Create a ``Configuration`` from PyProjectData with full workflow.
+
+        Canonical entry point for integrators. Orchestrates:
+        1. Extract config from pyproject_data.section
+        2. Determine dist_name
+        3. Apply integrator overrides
+        4. Apply environment TOML overrides
+        5. Build and validate Configuration with this env attached
+        """
+        from ._integrator_helpers import build_configuration_from_pyproject_internal
+
+        return build_configuration_from_pyproject_internal(
+            pyproject_data=pyproject_data,
+            dist_name=dist_name,
+            env=self,
+            **integrator_overrides,
+        )
+
+    def pyproject_tool_names(self) -> list[str]:
+        """Derive TOML section names from env-var prefixes.
+
+        Maps env-var prefixes to their canonical pyproject [tool.X] section
+        names. The ``VCS_VERSIONING`` prefix always maps to ``vcs-versioning``
+        (with dash). Other prefixes are lowercased with underscores preserved.
+
+        Examples:
+            - ``SETUPTOOLS_SCM`` -> ``setuptools_scm``
+            - ``VCS_VERSIONING`` -> ``vcs-versioning``
+            - ``HATCH_VCS`` -> ``hatch_vcs``
+
+        .. todo::
+            This uses special-case mapping (VCS_VERSIONING -> vcs-versioning).
+            The tool names should be made properly configurable via an explicit
+            mapping parameter on VcsEnvironment rather than guessing from
+            env-var prefix casing conventions.
+        """
+        result: list[str] = []
+        for name in self.tool_names:
+            if name == "VCS_VERSIONING":
+                result.append("vcs-versioning")
+            else:
+                result.append(name.lower())
+        return result
+
+    def read_toml_overrides(
+        self, dist_name: str | None
+    ) -> _overrides.ConfigOverridesDict:
+        """Read TOML config overrides from environment variables.
+
+        Uses this environment's tool_names and env dict, delegating to
+        the standalone ``read_toml_overrides`` function.
+        """
+        from ._overrides import read_toml_overrides as _read_toml_overrides
+
+        return _read_toml_overrides(
+            dist_name, tool_names=self.tool_names, env=self._env
+        )

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_get_version_impl.py

@@ -29,6 +29,18 @@ EMPTY_TAG_REGEX_DEPRECATION = DeprecationWarning(
 log = logging.getLogger(__name__)
 
 
+def parse_version(config: Configuration) -> ScmVersion | None:
+    """Backward-compat shim for setuptools-scm <=10.0.x.
+
+    Those releases import ``parse_version`` from this module.  The function
+    was inlined during the 10.1 / vcs-versioning 2.0 refactor, but we keep
+    the name importable so that older setuptools-scm pins still work with
+    newer vcs-versioning releases.
+    """
+    scm_version = _resolve_version(config)
+    return _apply_metadata_overrides(scm_version, config)
+
+
 def _finalize(
     scm_version: ScmVersion,
     config: Configuration,

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_integrator_helpers.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from ._config import Configuration
+    from ._environment import VcsEnvironment
     from ._pyproject_reading import PyProjectData
 
 log = logging.getLogger(__name__)
@@ -22,6 +23,7 @@ def build_configuration_from_pyproject_internal(
     pyproject_data: PyProjectData,
     *,
     dist_name: str | None = None,
+    env: VcsEnvironment | None = None,
     **integrator_overrides: Any,
 ) -> Configuration:
     """Build Configuration with complete workflow orchestration.
@@ -34,7 +36,7 @@ def build_configuration_from_pyproject_internal(
     2. Determine dist_name (argument > pyproject.project_name)
     3. Merge integrator overrides (override config file)
     4. Read and apply env TOML overrides (highest priority)
-    5. Build Configuration with proper validation
+    5. Build Configuration with proper validation and VcsEnvironment attached
 
     Priority order (highest to lowest):
         1. Environment TOML overrides (TOOL_OVERRIDES_FOR_DIST, TOOL_OVERRIDES)
@@ -45,6 +47,8 @@ def build_configuration_from_pyproject_internal(
     Args:
         pyproject_data: Parsed pyproject data from PyProjectData.from_file() or manual composition
         dist_name: Distribution name for env var lookups (overrides pyproject_data.project_name)
+        env: Optional VcsEnvironment. If None, resolves from the active
+             GlobalOverrides context or process environment.
         **integrator_overrides: Integrator-provided config overrides
                                (override config file, but overridden by env)
 
@@ -67,9 +71,12 @@ def build_configuration_from_pyproject_internal(
     """
     # Import here to avoid circular dependencies
     from ._config import Configuration
-    from ._overrides import read_toml_overrides
+    from ._environment import resolve_runtime_env
     from ._pyproject_reading import get_args_for_pyproject
 
+    if env is None:
+        env = resolve_runtime_env()
+
     # Step 1: Get base config from pyproject section
     # This also handles dist_name resolution
     log.debug(
@@ -96,8 +103,7 @@ def build_configuration_from_pyproject_internal(
         config_data.update(integrator_overrides)
 
     # Step 4: Apply environment TOML overrides (highest priority)
-    tool_names = (pyproject_data.tool_name.upper().replace("-", "_"),)
-    env_overrides = read_toml_overrides(actual_dist_name, tool_names=tool_names)
+    env_overrides = env.read_toml_overrides(actual_dist_name)
     if env_overrides:
         log.debug("Applying environment TOML overrides: %s", list(env_overrides.keys()))
         config_data.update(env_overrides)
@@ -106,7 +112,7 @@ def build_configuration_from_pyproject_internal(
     relative_to = pyproject_data.path
     log.debug("Building Configuration with relative_to=%s", relative_to)
 
-    return Configuration.from_data(relative_to=relative_to, data=config_data)
+    return Configuration.from_data(relative_to=relative_to, data=config_data, _env=env)
 
 
 __all__ = [

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_overrides.py

@@ -153,18 +153,18 @@ def _read_pretended_metadata_for(
     Returns a dictionary with metadata field overrides like:
     {"node": "g1337beef", "distance": 4}
     """
-    from .overrides import EnvReader
+    log.debug("dist name: %s", config.dist_name)
 
     if env is None:
-        env = config.env._env
-
-    log.debug("dist name: %s", config.dist_name)
+        reader = config.env.make_reader(config.dist_name)
+    else:
+        from .overrides import EnvReader
 
-    reader = EnvReader(
-        tools_names=config.env.tool_names,
-        env=env,
-        dist_name=config.dist_name,
-    )
+        reader = EnvReader(
+            tools_names=config.env.tool_names,
+            env=env,
+            dist_name=config.dist_name,
+        )
 
     try:
         metadata_overrides = reader.read_toml(
@@ -259,18 +259,18 @@ def _read_pretended_version_for(
     tries ``SETUPTOOLS_SCM_PRETEND_VERSION``
     and ``SETUPTOOLS_SCM_PRETEND_VERSION_FOR_$UPPERCASE_DIST_NAME``
     """
-    from .overrides import EnvReader
+    log.debug("dist name: %s", config.dist_name)
 
     if env is None:
-        env = config.env._env
-
-    log.debug("dist name: %s", config.dist_name)
+        reader = config.env.make_reader(config.dist_name)
+    else:
+        from .overrides import EnvReader
 
-    reader = EnvReader(
-        tools_names=config.env.tool_names,
-        env=env,
-        dist_name=config.dist_name,
-    )
+        reader = EnvReader(
+            tools_names=config.env.tool_names,
+            env=env,
+            dist_name=config.dist_name,
+        )
     pretended = reader.read("PRETEND_VERSION")
 
     if pretended:

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_run_cmd.py

@@ -166,6 +166,7 @@ def run(
         ),
         text=True,
         encoding="utf-8",
+        errors="surrogateescape",
         timeout=timeout,
     )
 

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_version_inference.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
+    from ._environment import VcsEnvironment
     from ._pyproject_reading import PyProjectData
 
 
@@ -14,6 +15,7 @@ def infer_version_string(
     overrides: dict[str, Any] | None = None,
     *,
     force_write_version_files: bool = False,
+    env: VcsEnvironment | None = None,
 ) -> str:
     """
     Compute the inferred version string from the given inputs.
@@ -27,6 +29,8 @@ def infer_version_string(
         pyproject_data: Parsed PyProjectData (may be constructed via for_testing())
         overrides: Optional override configuration (same keys as [tool.setuptools_scm])
         force_write_version_files: When True, apply write_to/version_file effects
+        env: Optional VcsEnvironment. If None, resolves from the active
+             GlobalOverrides context or process environment.
 
     Returns:
         The computed version string.
@@ -34,10 +38,13 @@ def infer_version_string(
     Raises:
         SystemExit: If version cannot be determined (via _version_missing)
     """
-    from ._config import Configuration
+    from ._environment import resolve_runtime_env
     from ._get_version_impl import _get_version, _version_missing
 
-    config = Configuration.from_file(
+    if env is None:
+        env = resolve_runtime_env()
+
+    config = env.build_config(
         dist_name=dist_name, pyproject_data=pyproject_data, **(overrides or {})
     )
 

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/src/vcs_versioning/_worktree_discovery.py

@@ -70,7 +70,10 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
        - ScmWorkdir result: verify project_path, return immediately.
        - FallbackWorkdir result: stash as candidate, keep probing for SCM.
     2. Fallback phase: probe ``project_dir`` (if different from scm root).
-    3. Return best stashed FallbackWorkdir if no SCM found.
+    3. Try each stashed FallbackWorkdir in discovery order; return the first
+       whose ``get_scm_version()`` is not None.  This prevents an
+       unprocessed ``.git_archival.txt`` from shadowing a valid ``PKG-INFO``
+       (see :issue:`1431`).
     4. Try StaticWorkdir from config.fallback_version / parentdir_prefix_version.
     5. Return None.
     """
@@ -92,7 +95,7 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
     project_dir = config._resolved_paths.project_dir
     scm_root_hint = config._resolved_paths.scm_probe_root
 
-    fallback_candidate: FallbackWorkdir | None = None
+    fallback_candidates: list[FallbackWorkdir] = []
 
     def _accept_scm(result: ScmWorkdir, ep_name: str) -> ScmWorkdir:
         result.project_root = project_dir
@@ -109,7 +112,6 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
         return result
 
     def _probe_dir(current_dir: Path, *, accept_scm: bool) -> ScmWorkdir | None:
-        nonlocal fallback_candidate
         for ep_name, factory in factories:
             try:
                 result = factory(current_dir, config=config)
@@ -122,7 +124,7 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
                 continue
             if accept_scm and isinstance(result, ScmWorkdir):
                 return _accept_scm(result, ep_name)
-            if isinstance(result, FallbackWorkdir) and fallback_candidate is None:
+            if isinstance(result, FallbackWorkdir):
                 result._config = config
                 log.debug(
                     "stashed fallback workdir %s from factory %s at %s",
@@ -130,7 +132,7 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
                     ep_name,
                     current_dir,
                 )
-                fallback_candidate = result
+                fallback_candidates.append(result)
         return None
 
     # Phase 1: SCM probes at scm_root_hint (the declared root) and optionally parents.
@@ -146,9 +148,19 @@ def discover_workdir(config: Configuration) -> AnyWorkdir | None:
     if project_dir != scm_root_hint:
         _probe_dir(project_dir, accept_scm=False)
 
-    if fallback_candidate is not None:
-        log.info("using fallback workdir %s", type(fallback_candidate).__name__)
-        return fallback_candidate
+    # Try each fallback candidate until one can provide a version (#1431).
+    # Earlier discovery code stashed all matching fallback workdirs; an
+    # unprocessed .git_archival.txt (raw $Format placeholders) would
+    # shadow a valid PKG-INFO if we only kept the first candidate.
+    for candidate in fallback_candidates:
+        if candidate.get_scm_version() is not None:
+            log.info("using fallback workdir %s", type(candidate).__name__)
+            return candidate
+    if fallback_candidates:
+        log.debug(
+            "all %d fallback candidates returned None for get_scm_version",
+            len(fallback_candidates),
+        )
 
     static = StaticWorkdir(path=project_dir, _config=config)
     if static.get_scm_version() is not None:

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0/src/vcs_versioning.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.0.1
+Version: 2.1.0
 Summary: the blessed package to manage your versions by vcs metadata
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
 License-Expression: MIT

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/testing_vcs/test_chain_api.py

@@ -304,3 +304,106 @@ class TestFrozenLegacyConfig:
         frozen = FrozenLegacyConfig(config)
         with pytest.raises((AttributeError, dataclasses.FrozenInstanceError)):
             frozen.version_scheme = "something"  # type: ignore[attr-defined]
+
+
+class TestInferVersionStringEnv:
+    """Tests that infer_version_string properly resolves and attaches VcsEnvironment."""
+
+    def _pyproject(self) -> PyProjectData:
+        return PyProjectData.for_testing(
+            tool_name="vcs-versioning",
+            is_required=True,
+            section_present=True,
+            project_present=True,
+            project_name="test-pkg",
+        )
+
+    def test_no_deprecation_warning_with_pretend_version(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """infer_version_string must not leak DeprecationWarning for missing env."""
+        import warnings
+
+        from vcs_versioning._version_inference import infer_version_string
+
+        monkeypatch.setenv("SETUPTOOLS_SCM_PRETEND_VERSION", "1.2.3")
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("error", category=DeprecationWarning)
+            result = infer_version_string("test-pkg", self._pyproject())
+
+        assert result == "1.2.3"
+
+    def test_resolves_env_from_global_overrides_context(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """infer_version_string respects the active GlobalOverrides context."""
+        from vcs_versioning._version_inference import infer_version_string
+
+        monkeypatch.setenv("MYTOOL_PRETEND_VERSION", "9.8.7")
+
+        with GlobalOverrides.from_env("MYTOOL"):
+            result = infer_version_string("test-pkg", self._pyproject())
+
+        assert result == "9.8.7"
+
+    def test_accepts_explicit_env(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """infer_version_string uses an explicitly passed VcsEnvironment."""
+        from vcs_versioning._version_inference import infer_version_string
+
+        env_mapping = {"VCS_VERSIONING_PRETEND_VERSION": "4.5.6"}
+        env = VcsEnvironment.from_env(env=env_mapping)
+
+        result = infer_version_string("test-pkg", self._pyproject(), env=env)
+        assert result == "4.5.6"
+
+
+class TestBuildConfigurationFromPyprojectEnv:
+    """Tests that build_configuration_from_pyproject attaches VcsEnvironment."""
+
+    def _pyproject(self) -> PyProjectData:
+        return PyProjectData.for_testing(
+            tool_name="vcs-versioning",
+            is_required=True,
+            section_present=True,
+            project_present=True,
+            project_name="test-pkg",
+        )
+
+    def test_no_deprecation_warning(self) -> None:
+        """build_configuration_from_pyproject must not leak DeprecationWarning."""
+        import warnings
+
+        from vcs_versioning import build_configuration_from_pyproject
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("error", category=DeprecationWarning)
+            config = build_configuration_from_pyproject(
+                self._pyproject(), dist_name="test-pkg"
+            )
+
+        assert config._env is not None
+
+    def test_resolves_env_from_global_overrides_context(self) -> None:
+        """build_configuration_from_pyproject uses active GlobalOverrides."""
+        from vcs_versioning import build_configuration_from_pyproject
+
+        with GlobalOverrides.from_env("MYTOOL", env={}):
+            config = build_configuration_from_pyproject(
+                self._pyproject(), dist_name="test-pkg"
+            )
+
+        assert config._env is not None
+        assert "MYTOOL" in config._env.tool_names
+
+    def test_accepts_explicit_env(self) -> None:
+        """build_configuration_from_pyproject passes explicit env through."""
+        from vcs_versioning import build_configuration_from_pyproject
+
+        env = VcsEnvironment.from_env("CUSTOM", env={})
+
+        config = build_configuration_from_pyproject(
+            self._pyproject(), dist_name="test-pkg", env=env
+        )
+
+        assert config._env is env

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/testing_vcs/test_regressions.py

@@ -138,6 +138,30 @@ def test_no_warn_when_version_file_not_tracked(tmp_path: Path, scm: str) -> None
     assert tracked_warnings == []
 
 
+@pytest.mark.issue(1423)
+def test_parse_version_importable_from_get_version_impl() -> None:
+    """setuptools-scm <=10.0.x imports parse_version from this module."""
+    from vcs_versioning._get_version_impl import parse_version
+
+    assert callable(parse_version)
+
+
+@pytest.mark.issue(1423)
+def test_parse_version_shim_returns_version(tmp_path: Path) -> None:
+    """The compat shim should resolve and return a ScmVersion."""
+    wd = WorkDir(tmp_path).setup_git()
+    wd.add_and_commit("initial")
+    wd("git tag -a v1.0.0 -m v1.0.0")
+
+    c = Configuration(root=tmp_path)
+
+    from vcs_versioning._get_version_impl import parse_version
+    from vcs_versioning._scm_version import ScmVersion
+
+    result = parse_version(c)
+    assert isinstance(result, ScmVersion)
+
+
 @pytest.mark.parametrize(
     ("input", "expected"),
     [

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/testing_vcs/test_tag_config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import warnings
 
-import pytest
 from vcs_versioning import Configuration
 from vcs_versioning._config import TagConfiguration
 from vcs_versioning._scm_version import tag_to_version
@@ -59,8 +58,10 @@ class TestDescribeMatchGlob:
 
 
 class TestTagStrictWarning:
-    def test_none_strict_emits_future_warning(self) -> None:
-        with pytest.warns(FutureWarning, match="tag.strict is not set"):
+    def test_none_strict_no_warning(self) -> None:
+        """tag.strict=None no longer warns (suppressed per #1422, see #1429)."""
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", FutureWarning)
             Configuration(tag=TagConfiguration(strict=None))
 
     def test_true_strict_no_warning(self) -> None:
@@ -78,17 +79,13 @@ class TestTagPrefixStripping:
     """Test that tag.prefix is stripped before tag_regex matching."""
 
     def test_prefix_stripped_from_tag(self) -> None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", FutureWarning)
-            config = Configuration(tag=TagConfiguration(prefix="hatchling-v"))
+        config = Configuration(tag=TagConfiguration(prefix="hatchling-v"))
         version = tag_to_version("hatchling-v1.0.0", config)
         assert version is not None
         assert str(version) == "1.0.0"
 
     def test_no_prefix_no_stripping(self) -> None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", FutureWarning)
-            config = Configuration(tag=TagConfiguration(prefix=""))
+        config = Configuration(tag=TagConfiguration(prefix=""))
         version = tag_to_version("v1.0.0", config)
         assert version is not None
         assert str(version) == "1.0.0"
@@ -100,17 +97,13 @@ class TestTagPrefixStripping:
         may still parse -- but the prefix is NOT stripped, meaning
         git describe --match would have already filtered it out in practice.
         """
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", FutureWarning)
-            config = Configuration(tag=TagConfiguration(prefix="other-"))
+        config = Configuration(tag=TagConfiguration(prefix="other-"))
         version = tag_to_version("hatchling-v1.0.0", config)
         # Default tag_regex matches and extracts "v1.0.0" from dashed prefix
         assert version is not None
 
     def test_prefix_v_strips_v(self) -> None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", FutureWarning)
-            config = Configuration(tag=TagConfiguration(prefix="v"))
+        config = Configuration(tag=TagConfiguration(prefix="v"))
         version = tag_to_version("v1.2.3", config)
         assert version is not None
         assert str(version) == "1.2.3"
@@ -120,20 +113,19 @@ class TestConfigFromData:
     """Test that Configuration.from_data correctly parses tag config."""
 
     def test_tag_in_from_data(self) -> None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", FutureWarning)
-            config = Configuration.from_data(
-                relative_to=".",
-                data={
-                    "dist_name": "test",
-                    "tag": {"prefix": "mylib-", "strict": True},
-                },
-            )
+        config = Configuration.from_data(
+            relative_to=".",
+            data={
+                "dist_name": "test",
+                "tag": {"prefix": "mylib-", "strict": True},
+            },
+        )
         assert config.tag.prefix == "mylib-"
         assert config.tag.strict is True
 
     def test_no_tag_in_from_data(self) -> None:
-        with pytest.warns(FutureWarning, match="tag.strict"):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", FutureWarning)
             config = Configuration.from_data(
                 relative_to=".",
                 data={"dist_name": "test"},
@@ -143,13 +135,12 @@ class TestConfigFromData:
 
 
 class TestDescribeCommandConflictWarning:
-    def test_warns_when_prefix_and_describe_command_both_set(self) -> None:
+    def test_no_warning_when_prefix_and_describe_command_both_set(self) -> None:
+        """Suppressed per #1422, see #1429 for follow-up."""
         from vcs_versioning._config import GitConfiguration, ScmConfiguration
 
-        with pytest.warns(
-            UserWarning,
-            match="Both tag.prefix/tag.strict and scm.git.describe_command are set",
-        ):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", UserWarning)
             Configuration(
                 tag=TagConfiguration(prefix="v", strict=True),
                 scm=ScmConfiguration(

{vcs_versioning-2.0.1 → vcs_versioning-2.1.0}/testing_vcs/test_workdir_discovery.py

@@ -177,6 +177,40 @@ class TestProjectPathVerificationInDiscovery:
             discover_workdir(config)
 
 
+class TestFallbackPriority:
+    @pytest.mark.issue(1431)
+    def test_unprocessed_archival_falls_through_to_pkginfo(
+        self, tmp_path: Path
+    ) -> None:
+        """Unprocessed .git_archival.txt must not shadow a valid PKG-INFO.
+
+        PyPI sdists contain both files: a .git_archival.txt with raw
+        ``$Format:...`` placeholders (never substituted because the sdist
+        was built by setuptools, not ``git archive``) and a PKG-INFO with
+        the correct version.  Before the fix, the archival fallback was
+        stashed as the sole candidate and its ``get_scm_version()`` returned
+        None, causing a LookupError.
+        """
+        (tmp_path / ".git_archival.txt").write_text(
+            "node: $Format:%H$\n"
+            "node-date: $Format:%cI$\n"
+            "describe-name: $Format:%(describe:tags=true)$\n"
+            "ref-names: $Format:%D$\n",
+            encoding="utf-8",
+        )
+        (tmp_path / "PKG-INFO").write_text(
+            "Metadata-Version: 2.1\nName: my-pkg\nVersion: 1.2.3\n",
+            encoding="utf-8",
+        )
+        config = Configuration(relative_to=str(tmp_path / "pyproject.toml"))
+        result = discover_workdir(config)
+        assert result is not None
+        assert isinstance(result, PkgInfoWorkdir)
+        version = result.get_scm_version()
+        assert version is not None
+        assert str(version.tag) == "1.2.3"
+
+
 class TestFallbackWorkdirDiscoveryFactories:
     def test_discover_archival_git(self, tmp_path: Path) -> None:
         from vcs_versioning._fallback_workdir import discover_archival