Determine development version hash without running git (#21212)

We've called git in a subprocess so that we can include
git version hash in the version (like 
`2.0.0+dev.32f307a7cca81c13db6bf6a7984493cefebd7b1e`). This
happens with development versions run in the git mypy repo.

Running git as a subprocess can dominate mypy startup time in certain
environments, so this PR adds logic to figure out current HEAD hash 
without running git. I've seen the git invocations add 200ms+ to mypy 
runtimes.

Unfortunately, we can't easily figure out if .dirty should be
added without git, so I'm just removing it altogether from the version.
Since startup overhead becomes a worse issue when using parallel
type checking, not having .dirty support seems like a smaller issue
than slow startup.

This was written using Claude Code.

Author: JukkaL

mypy/git.py

@@ -28,6 +28,41 @@ def git_revision(dir: str) -> bytes:
     return subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=dir).strip()
 
 
+def git_revision_no_subprocess(dir: str) -> bytes | None:
+    """Get the SHA-1 of HEAD by reading git files directly, without a subprocess.
+
+    Returns None if the revision cannot be determined this way (e.g. unusual
+    git state), in which case the caller should fall back to git_revision().
+    """
+    try:
+        head_path = os.path.join(dir, ".git", "HEAD")
+        with open(head_path, "rb") as f:
+            head = f.read().strip()
+        if head.startswith(b"ref: "):
+            ref = head[5:]  # e.g. b"refs/heads/main"
+            ref_path = os.path.join(dir, ".git", os.fsdecode(ref))
+            if os.path.exists(ref_path):
+                with open(ref_path, "rb") as f:
+                    return f.read().strip()
+            # The ref may be in packed-refs instead of a loose file.
+            packed_refs_path = os.path.join(dir, ".git", "packed-refs")
+            if os.path.exists(packed_refs_path):
+                with open(packed_refs_path, "rb") as f:
+                    for line in f:
+                        if line.startswith(b"#"):
+                            continue
+                        parts = line.strip().split()
+                        if len(parts) >= 2 and parts[1] == ref:
+                            return parts[0]
+            return None
+        # Detached HEAD: content is the SHA itself.
+        if len(head) == 40 and all(chr(c) in "0123456789abcdef" for c in head):
+            return head
+        return None
+    except OSError:
+        return None
+
+
 def is_dirty(dir: str) -> bool:
     """Check whether a git repository has uncommitted changes."""
     output = subprocess.check_output(["git", "status", "-uno", "--porcelain"], cwd=dir)

mypy/version.py

@@ -12,8 +12,10 @@
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
-if __version__.endswith("+dev") and git.is_git_repo(mypy_dir) and git.have_git():
-    __version__ += "." + git.git_revision(mypy_dir).decode("utf-8")
-    if git.is_dirty(mypy_dir):
-        __version__ += ".dirty"
+if __version__.endswith("+dev") and git.is_git_repo(mypy_dir):
+    revision = git.git_revision_no_subprocess(mypy_dir)
+    if revision is not None:
+        __version__ += "." + revision.decode("ascii")
+    elif git.have_git():
+        __version__ += "." + git.git_revision(mypy_dir).decode("utf-8")
 del mypy_dir