vcs-versioning 2.2.2__tar.gz → 2.2.4__tar.gz

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 <!-- towncrier release notes start -->
 
+## 2.2.4 (2026-08-07)
+
+### Fixed
+
+- Speed up jujutsu version inference in large repositories.
+
+  The jj backend filtered whole-ancestry revsets with `empty()`, which makes
+  jj diff every commit in the history and took minutes on large repos.  The
+  scan for the newest real commit is now bounded to the most recent
+  generations, distances are counted without the filter, and the working copy
+  is snapshotted only once per run (later queries pass
+  `--ignore-working-copy`).
+
+  As a side effect distances now match `git describe --long`: merge commits
+  count even though jj considers them empty. ([#1477](https://github.com/pypa/setuptools-scm/issues/1477))
+- Improve reproducibility of scm_file_list.json ([#1488](https://github.com/pypa/setuptools-scm/issues/1488))
+- Route the hg-git tag mismatch warning through the module logger instead of the root logger. ([#1489](https://github.com/pypa/setuptools-scm/issues/1489))
+
+## 2.2.3 (2026-07-28)
+
+### Fixed
+
+- Fix `ValueError` when parsing `.git_archival.txt` of a tagged commit whose tag contains more than one dash (e.g. `llvmorg-23.1.0-rc2`) - the `git describe` suffix is now matched precisely instead of splitting on the last two dashes. ([#1481](https://github.com/pypa/setuptools-scm/issues/1481))
+
 ## 2.2.2 (2026-06-29)
 
 ### Fixed

{vcs_versioning-2.2.2/src/vcs_versioning.egg-info → vcs_versioning-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.2.2
+Version: 2.2.4
 Summary: the blessed package to manage your versions by vcs metadata
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
 License: MIT
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: packaging>=20
+Requires-Dist: packaging>=26.2
 Requires-Dist: tomli>=1; python_version < "3.11"
 Requires-Dist: typing-extensions>=4.1; python_version < "3.11"
 Dynamic: license-file

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/pyproject.toml

@@ -7,7 +7,7 @@
 build-backend = "setuptools.build_meta"
 requires = [
   "setuptools>=45",
-  "packaging>=20",
+  "packaging>=26.2",
   'typing-extensions>=4.1; python_version < "3.11"',
 ]
 
@@ -38,7 +38,7 @@ dynamic = [
   "version",
 ]
 dependencies = [
-  "packaging>=20",
+  "packaging>=26.2",
   'tomli>=1; python_version < "3.11"',
   'typing-extensions>=4.1; python_version < "3.11"',
 ]

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_backends/_git.py

@@ -33,6 +33,11 @@ log = logging.getLogger(__name__)
 REF_TAG_RE = re.compile(r"(?<=\btag: )([^,]+)\b")
 DESCRIBE_UNSUPPORTED = "%(describe"
 
+# ``git describe`` appends ``-<distance>-g<abbreviated node>`` to the tag name.
+# Tags may contain dashes themselves, so the suffix has to be matched precisely
+# instead of just splitting on the last two dashes.
+DESCRIBE_SUFFIX_RE = re.compile(r"^(?P<tag>.+)-(?P<distance>\d+)-g(?P<node>[0-9a-f]+)$")
+
 
 # If testing command in shell make sure to quote the match argument like
 # '*[0-9]*' as it will expand before being sent to git if there are any matching
@@ -250,7 +255,7 @@ class GitWorkdir(Workdir):
         git_files, git_dirs = _git_ls_files_and_dirs(
             str(self.path), timeout=self._subprocess_timeout
         )
-        return scm_find_files(base, git_files, git_dirs)
+        return sorted(scm_find_files(base, git_files, git_dirs))
 
     def is_file_tracked(self, path: Path) -> bool:
         res = self.run_git(
@@ -473,15 +478,15 @@ def _git_parse_describe(
     else:
         dirty = False
 
-    split = describe_output.rsplit("-", 2)
-    if len(split) < 3:  # probably a tagged commit
-        tag = describe_output
-        number = 0
-        node = None
-    else:
-        tag, number_, node = split
-        number = int(number_)
-    return tag, number, node, dirty
+    match = DESCRIBE_SUFFIX_RE.match(describe_output)
+    if match is None:  # probably a tagged commit
+        return describe_output, 0, None, dirty
+    return (
+        match.group("tag"),
+        int(match.group("distance")),
+        "g" + match.group("node"),
+        dirty,
+    )
 
 
 def archival_to_version(

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_backends/_hg_git.py

@@ -191,7 +191,7 @@ class GitWorkdirHgClient(GitWorkdir, HgWorkdir):
                 tag = hg_tag
                 break
         else:
-            logging.warning("tag not found hg=%s git=%s", hg_tags, git_tags)
+            log.warning("tag not found hg=%s git=%s", hg_tags, git_tags)
             return _FAKE_GIT_DESCRIBE_ERROR
 
         res = self.run_hg(["log", "-r", f"'{tag}'::.", "-T", "."])

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_backends/_jj.py

@@ -35,6 +35,16 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
+ANCESTOR_SCAN_LIMIT = 20
+"""Generations of ancestors examined when looking for the newest real commit.
+
+Revsets filtered by ``empty()`` force jj to diff every candidate commit
+against its parents, so applying such a filter to the full ancestry costs
+O(history) and takes minutes in large repositories (issue #1477).  Empty
+commits only occur near the head in practice -- ``@`` itself, plus the
+occasional ``jj new`` chain -- so a small window suffices.
+"""
+
 
 def run_jj(
     args: Sequence[str | os.PathLike[str]],
@@ -42,27 +52,45 @@ def run_jj(
     *,
     check: bool = False,
     timeout: int | None = None,
+    ignore_working_copy: bool = False,
 ) -> _CompletedProcess:
-    return _run(
-        ["jj", "--no-pager", "--repository", str(repo), *args],
-        cwd=repo,
-        check=check,
-        timeout=timeout,
-    )
+    cmd: list[str | os.PathLike[str]] = ["jj", "--no-pager", "--repository", str(repo)]
+    if ignore_working_copy:
+        cmd.append("--ignore-working-copy")
+    cmd.extend(args)
+    return _run(cmd, cwd=repo, check=check, timeout=timeout)
 
 
 class JjWorkdir(Workdir):
     """Work directory backed by Jujutsu (jj)."""
 
+    _snapshot_taken: bool = False
+    """Whether a command in this process refreshed the working-copy commit."""
+
     def run_jj(
         self,
         args: Sequence[str | os.PathLike[str]],
         *,
         check: bool = False,
         timeout: int | None = None,
+        needs_snapshot: bool = False,
     ) -> _CompletedProcess:
+        """Run a jj command in this work directory.
+
+        jj snapshots the working copy on every invocation, which scans the
+        whole tree and writes an operation-log entry.  One snapshot per
+        process is enough, so history queries following it pass
+        ``--ignore-working-copy``.  Commands that must observe uncommitted
+        edits set ``needs_snapshot``.
+        """
+        ignore_working_copy = self._snapshot_taken and not needs_snapshot
+        self._snapshot_taken = True
         return run_jj(
-            args, self.path, check=check, timeout=timeout or self._subprocess_timeout
+            args,
+            self.path,
+            check=check,
+            timeout=timeout or self._subprocess_timeout,
+            ignore_working_copy=ignore_working_copy,
         )
 
     @classmethod
@@ -74,7 +102,7 @@ class JjWorkdir(Workdir):
             return None
 
         timeout = config.env.subprocess_timeout if config is not None else None
-        res = run_jj(["root"], wd, timeout=timeout)
+        res = run_jj(["root"], wd, timeout=timeout, ignore_working_copy=True)
         root = res.parse_success(parse=str)
         if root is None:
             return None
@@ -84,7 +112,7 @@ class JjWorkdir(Workdir):
         return result
 
     def is_dirty(self) -> bool:
-        res = self.run_jj(["diff", "--summary"])
+        res = self.run_jj(["diff", "--summary"], needs_snapshot=True)
         return res.parse_success(parse=bool, default=False)
 
     def get_branch(self) -> str | None:
@@ -133,25 +161,41 @@ class JjWorkdir(Workdir):
             error_msg="failed to get jj head date",
         )
 
+    def _count_revset(self, revset: str) -> int:
+        """Count the commits a revset resolves to."""
+        res = self.run_jj(["log", "--no-graph", "-r", revset, "-T", '"x\\n"'])
+        output = res.parse_success(parse=str)
+        if not output:
+            return 0
+        return output.count("\n") + 1
+
     def node(self) -> str | None:
-        res = self.run_jj(
-            [
-                "log",
-                "--no-graph",
-                "-r",
-                "latest(::@ ~ (empty() ~ tags()))",
-                "-T",
-                "commit_id",
-            ],
-        )
-        result = res.parse_success(parse=str)
-        return result if result else None
+        """Return the newest ancestor of ``@`` that is a real commit.
 
-    def _find_latest_tag(self) -> tuple[str | None, str | None]:
-        """Find the latest tagged ancestor of the working copy.
+        This is jj's equivalent of git's ``HEAD``: the working-copy commit
+        ``@`` is skipped while it holds no changes, as are the empty
+        commits a ``jj new`` chain leaves behind.  Merges and tagged
+        commits are kept even when empty -- git counts them too.
 
-        Returns (tag_name, commit_id) or (None, None) if no tags found.
+        Only ``ANCESTOR_SCAN_LIMIT`` generations are examined; the
+        unbounded query remains as a fallback for histories that are
+        empty all the way down.
         """
+        skip = "empty() ~ tags() ~ merges()"
+        revsets = [
+            f"latest(ancestors(@, {ANCESTOR_SCAN_LIMIT}) ~ ({skip}))",
+            f"latest(::@ ~ ({skip}))",
+        ]
+        for revset in revsets:
+            res = self.run_jj(["log", "--no-graph", "-r", revset, "-T", "commit_id"])
+            result = res.parse_success(parse=str)
+            if result:
+                return result
+            log.debug("no non-empty commit found in %s", revset)
+        return None
+
+    def _find_latest_tag(self) -> str | None:
+        """Find the tag of the latest tagged ancestor of the working copy."""
         res = self.run_jj(
             [
                 "log",
@@ -159,93 +203,58 @@ class JjWorkdir(Workdir):
                 "-r",
                 "latest(heads(::@ & tags()))",
                 "-T",
-                'tags.map(|t| t.name()).join(",") ++ "\\n" ++ commit_id',
+                'tags.map(|t| t.name()).join(",")',
             ],
         )
-        output = res.parse_success(parse=str)
-        if not output:
-            return None, None
-
-        lines = output.strip().split("\n")
-        if len(lines) < 2:
-            return None, None
-
-        tag_names = lines[0].strip()
-        commit_id = lines[1].strip()
+        tag_names = res.parse_success(parse=str)
         if not tag_names:
-            return None, None
+            return None
 
         # Take the first tag if multiple point at the same commit
-        tag = tag_names.split(",")[0].strip()
-        return tag, commit_id
+        return tag_names.split(",")[0].strip() or None
 
-    def _compute_distance(self, tag_name: str) -> int:
-        """Count non-empty commits between a tag and the working copy.
+    def _compute_distance(self, tag_name: str, node: str) -> int:
+        """Count the commits between a tag and ``node``.
 
-        In jj's model the working copy ``@`` is a real commit.  If it
-        contains changes it is counted as one commit of distance, which
-        is the semantically correct representation.
+        Mirrors ``git describe --long``: every commit in the range is
+        counted, the tagged commit itself is not.
         """
-        res = self.run_jj(
-            [
-                "log",
-                "--no-graph",
-                "-r",
-                f'"{tag_name}"::@ ~ empty()',
-                "-T",
-                'commit_id ++ "\\n"',
-            ],
-        )
-        output = res.parse_success(parse=str)
-        if not output:
-            return 0
+        return max(0, self._count_revset(f'"{tag_name}"::{node}') - 1)
 
-        # Each non-empty line is a commit; subtract 1 for the tagged commit itself
-        commits = [line for line in output.strip().split("\n") if line.strip()]
-        return max(0, len(commits) - 1)
+    def _count_ancestors(self, node: str) -> int:
+        """Count the ancestors of ``node``, excluding jj's virtual root."""
+        return self._count_revset(f"::{node} ~ root()")
 
     def count_all_nodes(self) -> int:
-        res = self.run_jj(
-            [
-                "log",
-                "--no-graph",
-                "-r",
-                "::@ ~ empty()",
-                "-T",
-                'commit_id ++ "\\n"',
-            ],
-        )
-        output = res.parse_success(parse=str)
-        if not output:
-            return 0
-        return len([line for line in output.strip().split("\n") if line.strip()])
+        node = self.node()
+        return self._count_ancestors(node) if node is not None else 0
 
     def get_scm_version(self) -> ScmVersion | None:
         config = self.config
 
-        tag_name, _tag_commit = self._find_latest_tag()
+        # first command in the process -- refreshes the working-copy commit
+        # so that the emptiness of ``@`` below reflects uncommitted edits
         dirty = self.is_dirty()
 
+        node = self.node()
+        tag_name = self._find_latest_tag()
+
         if tag_name is not None:
-            distance = self._compute_distance(tag_name)
-            node = self.node()
-            if node:
-                node = "j" + node[:12]
+            distance = 0 if node is None else self._compute_distance(tag_name, node)
             version = meta(
                 tag=tag_name,
                 distance=distance,
                 dirty=dirty,
-                node=node,
+                node=None if node is None else "j" + node[:12],
                 config=config,
             )
         else:
             tag = config.version_cls(config.fallback_version or "0.0")
-            node = self.node()
             if node is None:
                 distance = 0
                 dirty = True
             else:
-                distance = self.count_all_nodes()
+                distance = self._count_ancestors(node)
                 node = "j" + node[:12]
             version = meta(
                 tag=tag, distance=distance, dirty=dirty, node=node, config=config
@@ -270,7 +279,7 @@ class JjWorkdir(Workdir):
         return scm_find_files(base, jj_files, jj_dirs)
 
     def is_file_tracked(self, path: Path) -> bool:
-        res = self.run_jj(["file", "list", str(path)])
+        res = self.run_jj(["file", "list", str(path)], needs_snapshot=True)
         output = res.parse_success(parse=str)
         return bool(output)
 

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_cli/__init__.py

@@ -80,7 +80,6 @@ def main(
         return command(opts, version, config)
 
 
-# flake8: noqa: C901
 def command(opts: CliNamespace, version: str, config: Configuration) -> int:
     data: OutputData = {}
 

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_file_finders/_git.py

@@ -21,7 +21,7 @@ def _git_toplevel(path: str) -> str | None:
         res = _run(["git", "rev-parse", "HEAD"], cwd=cwd)
         if res.returncode:
             # This catches you being in a git directory, but the
-            # permissions being incorrect.  With modern contanizered
+            # permissions being incorrect.  With modern containerized
             # CI environments you can easily end up in a cloned repo
             # with incorrect permissions and we don't want to silently
             # ignore files.
@@ -119,4 +119,4 @@ def git_archive_find_files(path: _t.PathT = "") -> list[str]:
     return scm_find_files(path, set(), set(), force_all_files=True)
 
 
-__all__ = ["git_find_files", "git_archive_find_files"]
+__all__ = ["git_archive_find_files", "git_find_files"]

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_file_finders/_hg.py

@@ -68,4 +68,4 @@ def hg_archive_find_files(path: _t.PathT = "") -> list[str]:
     return scm_find_files(path, set(), set(), force_all_files=True)
 
 
-__all__ = ["hg_find_files", "hg_archive_find_files"]
+__all__ = ["hg_archive_find_files", "hg_find_files"]

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_file_finders/_jj.py

@@ -21,7 +21,7 @@ log = logging.getLogger(__name__)
 def _jj_toplevel(path: str) -> str | None:
     try:
         cwd = os.path.abspath(path or ".")
-        res = _run(["jj", "root", "--no-pager"], cwd=cwd)
+        res = _run(["jj", "root", "--no-pager", "--ignore-working-copy"], cwd=cwd)
         if res.returncode:
             return None
         toplevel = res.stdout.strip()

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_get_version_impl.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
 # Backward-compat re-export used by vcs-versioning/setup.py
 from ._legacy_parse import (
-    resolved_fallback_root as resolved_fallback_root,  # noqa: F401
+    resolved_fallback_root as resolved_fallback_root,
 )
 from ._overrides import _apply_metadata_overrides, _read_pretended_version_for
 from ._scm_version import ScmVersion

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_legacy_parse.py

@@ -80,8 +80,8 @@ def parse_scm_version(config: Configuration) -> ScmVersion | None:
             entrypoint="setuptools_scm.parse_scm",
             root=config.absolute_root,
         )
-    except _run_cmd.CommandNotFoundError as e:
-        log.exception("command %s not found while parsing the scm, using fallbacks", e)
+    except _run_cmd.CommandNotFoundError:
+        log.exception("command not found while parsing the scm, using fallbacks")
         return None
 
 

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_paths.py

@@ -116,7 +116,7 @@ def _check_absolute_root(root: _t.PathT, relative_to: _t.PathT | None) -> str:
         if (
             os.path.isabs(root)
             and os.path.isabs(relative_to)
-            and not os.path.commonpath([root, relative_to]) == root
+            and os.path.commonpath([root, relative_to]) != root
         ):
             warnings.warn(
                 f"absolute root path '{root}' overrides relative_to '{relative_to}'",

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_run_cmd.py

@@ -157,6 +157,7 @@ def run(
         timeout = _get_timeout(os.environ)
     res = subprocess.run(
         cmd,
+        check=False,  # handled below via CompletedProcess.check_returncode
         capture_output=True,
         cwd=os.fspath(cwd),
         env=dict(

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_version_schemes/_standard.py

@@ -174,9 +174,8 @@ def guess_next_date_ver(
         # deduct date format if not provided
         if date_fmt is None:
             date_fmt = "%Y.%m.%d" if len(match.group("year")) == 4 else "%y.%m.%d"
-        if prefix := match.group("prefix"):
-            if not date_fmt.startswith(prefix):
-                date_fmt = prefix + date_fmt
+        if (prefix := match.group("prefix")) and not date_fmt.startswith(prefix):
+            date_fmt = prefix + date_fmt
 
     today = version.time.date()
     head_date = node_date or today

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/overrides.py

@@ -20,11 +20,17 @@ from __future__ import annotations
 import contextvars
 import logging
 import os
+import sys
 from collections.abc import Mapping, MutableMapping
 from contextlib import ContextDecorator
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Literal, TypedDict, TypeVar, overload
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 from packaging.utils import canonicalize_name
 
 from ._overrides import (
@@ -262,7 +268,7 @@ class GlobalOverrides:
             version = get_version(...)
     """
 
-    __slots__ = ("vcs_env", "tool", "dist_name", "_token")
+    __slots__ = ("_token", "dist_name", "tool", "vcs_env")
 
     def __init__(
         self,
@@ -361,13 +367,13 @@ class GlobalOverrides:
     # Context manager
     # ------------------------------------------------------------------
 
-    def __enter__(self) -> GlobalOverrides:
+    def __enter__(self) -> Self:
         """Enter context: set this as the active override and configure logging."""
         self._token = _active_overrides.set(self)
         self.vcs_env.configure_logging()
         return self
 
-    def __exit__(self, *exc_info: Any) -> None:
+    def __exit__(self, *exc_info: object) -> None:
         """Exit context: restore previous override state."""
         if self._token is not None:
             _active_overrides.reset(self._token)
@@ -523,7 +529,7 @@ class ensure_context(ContextDecorator):
         )
         return self._context.__enter__()
 
-    def __exit__(self, *exc_info: Any) -> None:
+    def __exit__(self, *exc_info: object) -> None:
         """Exit context: only exit if we created the context."""
         if self._created_context and self._context is not None:
             self._context.__exit__(*exc_info)

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4/src/vcs_versioning.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vcs-versioning
-Version: 2.2.2
+Version: 2.2.4
 Summary: the blessed package to manage your versions by vcs metadata
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>
 License: MIT
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: packaging>=20
+Requires-Dist: packaging>=26.2
 Requires-Dist: tomli>=1; python_version < "3.11"
 Requires-Dist: typing-extensions>=4.1; python_version < "3.11"
 Dynamic: license-file

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning.egg-info/requires.txt

@@ -1,4 +1,4 @@
-packaging>=20
+packaging>=26.2
 
 [:python_version < "3.11"]
 tomli>=1

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/testing_vcs/test_git.py

@@ -14,7 +14,7 @@ from unittest.mock import Mock, patch
 import pytest
 
 # File finder imports (now in vcs_versioning)
-import vcs_versioning._file_finders  # noqa: F401
+import vcs_versioning._file_finders
 import vcs_versioning._file_finders._git
 from vcs_versioning import Configuration
 from vcs_versioning._backends import _git
@@ -50,10 +50,15 @@ def wd(wd: WorkDir, monkeypatch: pytest.MonkeyPatch, debug_mode: DebugMode) -> W
     [
         ("3.3.1-rc26-0-g9df187b", "3.3.1-rc26", 0, "g9df187b", False),
         ("17.33.0-rc-17-g38c3047c0", "17.33.0-rc", 17, "g38c3047c0", False),
+        ("v1.15.1rc1-37-g9bd1298-dirty", "v1.15.1rc1", 37, "g9bd1298", True),
+        # bare tags containing dashes must not be mistaken for describe output
+        ("llvmorg-23.1.0-rc2", "llvmorg-23.1.0-rc2", 0, None, False),
+        ("llvmorg-23.1.0-rc2-dirty", "llvmorg-23.1.0-rc2", 0, None, True),
+        ("release-1.2.2", "release-1.2.2", 0, None, False),
     ],
 )
 def test_parse_describe_output(
-    given: str, tag: str, number: int, node: str, dirty: bool
+    given: str, tag: str, number: int, node: str | None, dirty: bool
 ) -> None:
     parsed = _git._git_parse_describe(given)
     assert parsed == (tag, number, node, dirty)
@@ -499,7 +504,6 @@ def test_non_dotted_tag_no_version_match(wd: WorkDir) -> None:
 
 @pytest.mark.issue("https://github.com/pypa/setuptools-scm/issues/381")
 def test_gitdir(monkeypatch: pytest.MonkeyPatch, wd: WorkDir) -> None:
-    """ """
     wd.commit_testfile()
     normal = wd.get_version()
     # git hooks set this and break subsequent setuptools-scm unless we clean
@@ -650,6 +654,18 @@ def test_git_archival_to_version(expected: str, from_data: dict[str, str]) -> No
     assert format_version(version) == expected
 
 
+@pytest.mark.issue("https://github.com/pypa/setuptools-scm/issues/1481")
+def test_git_archival_bare_tag_with_dashes() -> None:
+    config = Configuration(tag_regex=r"^llvmorg-(?P<version>.+)$")
+    version = archival_to_version(
+        {"describe-name": "llvmorg-23.1.0-rc2"}, config=config
+    )
+    assert version is not None
+    assert str(version.tag) == "23.1.0rc2"
+    assert version.distance == 0
+    assert version.node is None
+
+
 @pytest.mark.issue("https://github.com/pypa/setuptools-scm/issues/727")
 def test_git_archival_node_missing_no_version() -> None:
     config = Configuration()

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/testing_vcs/test_jj.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
+from typing import Any
 from unittest.mock import patch
 
 import pytest
@@ -11,7 +12,7 @@ from vcs_versioning import Configuration
 from vcs_versioning._backends import _jj as jj
 from vcs_versioning._backends._discover_vcs import discover
 from vcs_versioning._file_finders._jj import jj_find_files
-from vcs_versioning._run_cmd import CommandNotFoundError
+from vcs_versioning._run_cmd import CommandNotFoundError, CompletedProcess, run
 from vcs_versioning.test_api import DebugMode, WorkDir
 
 
@@ -104,6 +105,65 @@ def test_jj_distance(wd: WorkDir) -> None:
     assert str(version.tag) == "1.0.0"
 
 
+@pytest.mark.issue(1477)
+def test_jj_distance_counts_merges_like_git(wd: WorkDir) -> None:
+    """Merges are empty in jj terms but git counts them -- so do we."""
+    wd.commit_testfile()
+    wd("jj tag set v1.0.0 -r @-")
+    wd.commit_testfile()
+    main = wd("jj log --no-graph -r @- -T commit_id")
+
+    wd("jj new v1.0.0 -m side")
+    wd.write("side.txt", "side")
+    wd.add_and_commit("side")
+    side = wd("jj log --no-graph -r @- -T commit_id")
+
+    wd(f"jj new {main} {side} -m merge")
+    wd("jj commit -m merged")
+
+    version = jj.parse(wd.cwd, Configuration())
+    assert version is not None
+    assert version.distance == int(wd("git rev-list --count v1.0.0..HEAD"))
+    assert version.node == "j" + wd("git rev-parse HEAD")[:12]
+
+
+@pytest.mark.issue(1477)
+def test_jj_avoids_scanning_the_whole_history(
+    wd: WorkDir, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``empty()`` costs one commit diff per candidate -- keep it bounded.
+
+    An unbounded ``empty()`` filter turns version inference into a
+    minutes-long operation on large repositories.
+    """
+    wd.commit_testfile()
+    wd("jj tag set v1.0.0 -r @-")
+    wd.commit_testfile()
+
+    commands: list[list[str]] = []
+
+    def record(cmd: list[str], cwd: Path, **kwargs: Any) -> CompletedProcess:
+        commands.append([str(part) for part in cmd])
+        return run(cmd, cwd, **kwargs)
+
+    monkeypatch.setattr("vcs_versioning._backends._jj._run", record)
+    assert jj.parse(wd.cwd, Configuration()) is not None
+
+    revsets = [
+        cmd[index + 1]
+        for cmd in commands
+        for index, arg in enumerate(cmd)
+        if arg == "-r"
+    ]
+    assert revsets
+    bound = f"ancestors(@, {jj.ANCESTOR_SCAN_LIMIT})"
+    assert all("empty()" not in revset or bound in revset for revset in revsets)
+
+    # the working copy is snapshotted once, the history queries reuse it
+    snapshotting = [cmd for cmd in commands if "--ignore-working-copy" not in cmd]
+    assert len(snapshotting) == 1
+
+
 def test_jj_branch_detection(wd: WorkDir) -> None:
     wd.commit_testfile()
     wd("jj bookmark create test-branch -r @-")
@@ -144,9 +204,8 @@ def test_jj_missing_binary_errors(tmp_path: Path) -> None:
 
     with patch(
         "vcs_versioning._backends._discover_vcs.has_command", return_value=False
-    ):
-        with pytest.raises(LookupError, match="jj.*not available"):
-            discover(tmp_path, config=config)
+    ), pytest.raises(LookupError, match="jj.*not available"):
+        discover(tmp_path, config=config)
 
 
 def test_jj_colocated_prefers_jj(wd: WorkDir) -> None:

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/testing_vcs/test_mercurial.py

@@ -4,7 +4,7 @@ import os
 import warnings
 
 import pytest
-import vcs_versioning._file_finders  # noqa: F401
+import vcs_versioning._file_finders
 from vcs_versioning import Configuration
 from vcs_versioning._backends._hg import archival_to_version, parse
 from vcs_versioning._run_cmd import CommandNotFoundError

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/testing_vcs/test_version.py

@@ -233,7 +233,7 @@ def test_only_version(version: str) -> None:
 def test_tag_regex1(tag: str, expected: str) -> None:
     if "+" in tag:
         # pytest bug wrt cardinality
-        with pytest.warns(UserWarning):  # noqa: PT030
+        with pytest.warns(UserWarning):
             result = meta(tag, config=c)
     else:
         result = meta(tag, config=c)

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/uv.lock

@@ -317,7 +317,7 @@ test = [
 
 [package.metadata]
 requires-dist = [
-    { name = "packaging", specifier = ">=20" },
+    { name = "packaging", specifier = ">=26.2" },
     { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=1" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'", specifier = ">=4.1" },
 ]

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_file_finders/__init__.py

@@ -167,8 +167,8 @@ def collect_files_and_dirs(
 
 
 __all__ = [
-    "scm_find_files",
-    "is_toplevel_acceptable",
-    "find_files",
     "collect_files_and_dirs",
+    "find_files",
+    "is_toplevel_acceptable",
+    "scm_find_files",
 ]

{vcs_versioning-2.2.2 → vcs_versioning-2.2.4}/src/vcs_versioning/_types.py

@@ -16,12 +16,12 @@ if TYPE_CHECKING:
 from ._compat import PathT as PathT  # noqa: PLC0414
 
 __all__ = [
-    "PathT",
     "CMD_TYPE",
+    "GIT_PRE_PARSE",
+    "SCMVERSION",
     "VERSION_SCHEME",
     "VERSION_SCHEMES",
-    "SCMVERSION",
-    "GIT_PRE_PARSE",
+    "PathT",
 ]
 
 if TYPE_CHECKING: