Merge pull request #3599 from pre-commit/pre-commit-ci-update-config

[pre-commit.ci] pre-commit autoupdate

.github/ISSUE_TEMPLATE/00_bug.yaml

@@ -16,6 +16,12 @@ body:
       placeholder: ...
     validations:
       required: true
+  - type: markdown
+    attributes:
+      value: |
+        95% of issues created are duplicates.
+        please try extra hard to find them first.
+        it's very unlikely your problem is unique.
   - type: textarea
     id: freeform
     attributes:

.github/ISSUE_TEMPLATE/01_feature.yaml

@@ -0,0 +1,38 @@
+name: feature request
+description: something new
+body:
+  - type: markdown
+    attributes:
+      value: |
+         this is for issues for `pre-commit` (the framework).
+         if you are reporting an issue for [pre-commit.ci] please report it at [pre-commit-ci/issues]
+
+         [pre-commit.ci]: https://pre-commit.ci
+         [pre-commit-ci/issues]: https://github.com/pre-commit-ci/issues
+  - type: input
+    id: search
+    attributes:
+      label: search you tried in the issue tracker
+      placeholder: ...
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: |
+        95% of issues created are duplicates.
+        please try extra hard to find them first.
+        it's very unlikely your feature idea is a new one.
+  - type: textarea
+    id: freeform
+    attributes:
+      label: describe your actual problem
+      placeholder: 'I want to do ... I tried ... It does not work because ...'
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: pre-commit --version
+      placeholder: pre-commit x.x.x
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+- name: documentation
+  url: https://pre-commit.com
+  about: please check the docs first
+- name: pre-commit.ci issues
+  url: https://github.com/pre-commit-ci/issues
+  about: please report issues about pre-commit.ci here

.github/actions/pre-test/action.yml

@@ -5,36 +5,5 @@ inputs:
 runs:
   using: composite
   steps:
-  - name: setup (windows)
+  - uses: asottile/workflows/.github/actions/latest-git@v1.4.0
-    shell: bash
+    if: inputs.env == 'py39' && runner.os == 'Linux'
-    if: runner.os == 'Windows'
-    run: |
-      set -x
-
-      echo 'TEMP=C:\TEMP' >> "$GITHUB_ENV"
-
-      echo "$CONDA\Scripts" >> "$GITHUB_PATH"
-
-      echo 'C:\Strawberry\perl\bin' >> "$GITHUB_PATH"
-      echo 'C:\Strawberry\perl\site\bin' >> "$GITHUB_PATH"
-      echo 'C:\Strawberry\c\bin' >> "$GITHUB_PATH"
-
-      testing/get-coursier.sh
-      testing/get-dart.sh
-  - name: setup (linux)
-    shell: bash
-    if: runner.os == 'Linux'
-    run: |
-      set -x
-
-      sudo apt-get update
-      sudo apt-get install -y --no-install-recommends \
-        lua5.3 \
-        liblua5.3-dev \
-        luarocks
-
-      testing/get-coursier.sh
-      testing/get-dart.sh
-      testing/get-swift.sh
-  - uses: asottile/workflows/.github/actions/latest-git@v1.2.0
-    if: inputs.env == 'py38' && runner.os == 'Linux'

.github/workflows/languages.yaml

@@ -0,0 +1,84 @@
+name: languages
+
+on:
+  push:
+    branches: [main, test-me-*]
+    tags: '*'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  vars:
+    runs-on: ubuntu-latest
+    outputs:
+      languages: ${{ steps.vars.outputs.languages }}
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+    - name: install deps
+      run: python -mpip install -e . -r requirements-dev.txt
+    - name: vars
+      run: testing/languages ${{ github.event_name == 'push' && '--all' || '' }}
+      id: vars
+  language:
+    needs: [vars]
+    runs-on: ${{ matrix.os }}
+    if: needs.vars.outputs.languages != '[]'
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.vars.outputs.languages) }}
+    steps:
+    - uses: asottile/workflows/.github/actions/fast-checkout@v1.8.1
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+
+    - run: echo "$CONDA\Scripts" >> "$GITHUB_PATH"
+      shell: bash
+      if: matrix.os == 'windows-latest' && matrix.language == 'conda'
+    - run: testing/get-coursier.sh
+      shell: bash
+      if: matrix.language == 'coursier'
+    - run: testing/get-dart.sh
+      shell: bash
+      if: matrix.language == 'dart'
+    - run: |
+        sudo apt-get update
+        sudo apt-get install -y --no-install-recommends \
+          lua5.3 \
+          liblua5.3-dev \
+          luarocks
+      if: matrix.os == 'ubuntu-latest' && matrix.language == 'lua'
+    - run: |
+        echo 'C:\Strawberry\perl\bin' >> "$GITHUB_PATH"
+        echo 'C:\Strawberry\perl\site\bin' >> "$GITHUB_PATH"
+        echo 'C:\Strawberry\c\bin' >> "$GITHUB_PATH"
+      shell: bash
+      if: matrix.os == 'windows-latest' && matrix.language == 'perl'
+    - uses: haskell/actions/setup@v2
+      if: matrix.language == 'haskell'
+    - uses: r-lib/actions/setup-r@v2
+      if: matrix.os == 'ubuntu-latest' && matrix.language == 'r'
+
+    - name: install deps
+      run: python -mpip install -e . -r requirements-dev.txt
+    - name: run tests
+      run: coverage run -m pytest tests/languages/${{ matrix.language }}_test.py
+    - name: check coverage
+      run: coverage report --include pre_commit/languages/${{ matrix.language }}.py,tests/languages/${{ matrix.language }}_test.py
+  collector:
+    needs: [language]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+    - name: check for failures
+      if: contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled')
+      run: echo job failed && exit 1

.github/workflows/main.yml

@@ -3,7 +3,7 @@ name: main
 on:
   push:
     branches: [main, test-me-*]
-    tags:
+    tags: '*'
   pull_request:
 
 concurrency:
@@ -12,12 +12,12 @@ concurrency:
 
 jobs:
   main-windows:
-    uses: asottile/workflows/.github/workflows/tox.yml@v1.2.0
+    uses: asottile/workflows/.github/workflows/tox.yml@v1.8.1
     with:
-      env: '["py38"]'
+      env: '["py310"]'
       os: windows-latest
   main-linux:
-    uses: asottile/workflows/.github/workflows/tox.yml@v1.2.0
+    uses: asottile/workflows/.github/workflows/tox.yml@v1.8.1
     with:
-      env: '["py38", "py39", "py310"]'
+      env: '["py310", "py311", "py312", "py313"]'
       os: ubuntu-latest

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v6.0.0
     hooks:
     -   id: trailing-whitespace
     -   id: end-of-file-fixer
@@ -10,36 +10,35 @@ repos:
     -   id: name-tests-test
     -   id: requirements-txt-fixer
 -   repo: https://github.com/asottile/setup-cfg-fmt
-    rev: v2.2.0
+    rev: v3.2.0
     hooks:
     -   id: setup-cfg-fmt
--   repo: https://github.com/asottile/reorder_python_imports
+-   repo: https://github.com/asottile/reorder-python-imports
-    rev: v3.9.0
+    rev: v3.16.0
     hooks:
     -   id: reorder-python-imports
-        exclude: ^(pre_commit/resources/|testing/resources/python3_hooks_repo/)
+        exclude: ^pre_commit/resources/
-        args: [--py38-plus, --add-import, 'from __future__ import annotations']
+        args: [--py310-plus, --add-import, 'from __future__ import annotations']
 -   repo: https://github.com/asottile/add-trailing-comma
-    rev: v2.4.0
+    rev: v4.0.0
     hooks:
     -   id: add-trailing-comma
-        args: [--py36-plus]
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.3.1
+    rev: v3.21.2
     hooks:
     -   id: pyupgrade
-        args: [--py38-plus]
+        args: [--py310-plus]
--   repo: https://github.com/pre-commit/mirrors-autopep8
+-   repo: https://github.com/hhatto/autopep8
-    rev: v2.0.1
+    rev: v2.3.2
     hooks:
     -   id: autopep8
 -   repo: https://github.com/PyCQA/flake8
-    rev: 6.0.0
+    rev: 7.3.0
     hooks:
     -   id: flake8
 -   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
+    rev: v1.19.1
     hooks:
     -   id: mypy
-        additional_dependencies: [types-all]
+        additional_dependencies: [types-pyyaml]
         exclude: ^testing/resources/

CHANGELOG.md

@@ -1,3 +1,331 @@
+4.5.1 - 2025-12-16
+==================
+
+### Fixes
+- Fix `language: python` with `repo: local` without `additional_dependencies`.
+    - #3597 PR by @asottile.
+
+4.5.0 - 2025-11-22
+==================
+
+### Features
+- Add `pre-commit hazmat`.
+    - #3585 PR by @asottile.
+
+4.4.0 - 2025-11-08
+==================
+
+### Features
+- Add `--fail-fast` option to `pre-commit run`.
+    - #3528 PR by @JulianMaurin.
+- Upgrade `ruby-build` / `rbenv`.
+    - #3566 PR by @asottile.
+    - #3565 issue by @MRigal.
+- Add `language: unsupported` / `language: unsupported_script` as aliases
+  for `language: system` / `language: script` (which will eventually be
+  deprecated).
+    - #3577 PR by @asottile.
+- Add support docker-in-docker detection for cgroups v2.
+    - #3535 PR by @br-rhrbacek.
+    - #3360 issue by @JasonAlt.
+
+### Fixes
+- Handle when docker gives `SecurityOptions: null`.
+    - #3537 PR by @asottile.
+    - #3514 issue by @jenstroeger.
+- Fix error context for invalid `stages` in `.pre-commit-config.yaml`.
+    - #3576 PR by @asottile.
+
+4.3.0 - 2025-08-09
+==================
+
+### Features
+- `language: docker` / `language: docker_image`: detect rootless docker.
+    - #3446 PR by @matthewhughes934.
+    - #1243 issue by @dkolepp.
+- `language: julia`: avoid `startup.jl` when executing hooks.
+    - #3496 PR by @ericphanson.
+- `language: dart`: support latest dart versions which require a higher sdk
+  lower bound.
+    - #3507 PR by @bc-lee.
+
+4.2.0 - 2025-03-18
+==================
+
+### Features
+- For `language: python` first attempt a versioned python executable for
+  the default language version before consulting a potentially unversioned
+  `sys.executable`.
+    - #3430 PR by @asottile.
+
+### Fixes
+- Handle error during conflict detection when a file is named "HEAD"
+    - #3425 PR by @tusharsadhwani.
+
+4.1.0 - 2025-01-20
+==================
+
+### Features
+- Add `language: julia`.
+    - #3348 PR by @fredrikekre.
+    - #2689 issue @jmuchovej.
+
+### Fixes
+- Disable automatic toolchain switching for `language: golang`.
+    - #3304 PR by @AleksaC.
+    - #3300 issue by @AleksaC.
+    - #3149 issue by @nijel.
+- Fix `language: r` installation when initiated by RStudio.
+    - #3389 PR by @lorenzwalthert.
+    - #3385 issue by @lorenzwalthert.
+
+
+4.0.1 - 2024-10-08
+==================
+
+### Fixes
+- Fix `pre-commit migrate-config` for unquoted deprecated stages names with
+  purelib `pyyaml`.
+    - #3324 PR by @asottile.
+    - pre-commit-ci/issues#234 issue by @lorenzwalthert.
+
+4.0.0 - 2024-10-05
+==================
+
+### Features
+- Improve `pre-commit migrate-config` to handle more yaml formats.
+    - #3301 PR by @asottile.
+- Handle `stages` deprecation in `pre-commit migrate-config`.
+    - #3302 PR by @asottile.
+    - #2732 issue by @asottile.
+- Upgrade `ruby-build`.
+    - #3199 PR by @ThisGuyCodes.
+- Add "sensible regex" warnings to `repo: meta`.
+    - #3311 PR by @asottile.
+- Add warnings for deprecated `stages` (`commit` -> `pre-commit`, `push` ->
+  `pre-push`, `merge-commit` -> `pre-merge-commit`).
+    - #3312 PR by @asottile.
+    - #3313 PR by @asottile.
+    - #3315 PR by @asottile.
+    - #2732 issue by @asottile.
+
+### Updating
+- `language: python_venv` has been removed -- use `language: python` instead.
+    - #3320 PR by @asottile.
+    - #2734 issue by @asottile.
+
+3.8.0 - 2024-07-28
+==================
+
+### Features
+- Implement health checks for `language: r` so environments are recreated if
+  the system version of R changes.
+    - #3206 issue by @lorenzwalthert.
+    - #3265 PR by @lorenzwalthert.
+
+3.7.1 - 2024-05-10
+==================
+
+### Fixes
+- Fix `language: rust` default language version check when `rust-toolchain.toml`
+  is present.
+    - issue by @gaborbernat.
+    - #3201 PR by @asottile.
+
+3.7.0 - 2024-03-24
+==================
+
+### Features
+- Use a tty for `docker` and `docker_image` hooks when `--color` is specified.
+    - #3122 PR by @glehmann.
+
+### Fixes
+- Fix `fail_fast` for individual hooks stopping when previous hooks had failed.
+    - #3167 issue by @tp832944.
+    - #3168 PR by @asottile.
+
+### Updating
+- The per-hook behaviour of `fail_fast` was fixed.  If you want the pre-3.7.0
+  behaviour, add `fail_fast: true` to all hooks before the last `fail_fast`
+  hook.
+
+3.6.2 - 2024-02-18
+==================
+
+### Fixes
+- Fix building golang hooks during `git commit --all`.
+    - #3130 PR by @asottile.
+    - #2722 issue by @pestanko and @matthewhughes934.
+
+3.6.1 - 2024-02-10
+==================
+
+### Fixes
+- Remove `PYTHONEXECUTABLE` from environment when running.
+    - #3110 PR by @untitaker.
+- Handle staged-files-only with only a crlf diff.
+    - #3126 PR by @asottile.
+    - issue by @tyyrok.
+
+3.6.0 - 2023-12-09
+==================
+
+### Features
+- Check `minimum_pre_commit_version` first when parsing configs.
+    - #3092 PR by @asottile.
+
+### Fixes
+- Fix deprecation warnings for `importlib.resources`.
+    - #3043 PR by @asottile.
+- Fix deprecation warnings for rmtree.
+    - #3079 PR by @edgarrmondragon.
+
+### Updating
+- Drop support for python<3.9.
+    - #3042 PR by @asottile.
+    - #3093 PR by @asottile.
+
+3.5.0 - 2023-10-13
+==================
+
+### Features
+- Improve performance of `check-hooks-apply` and `check-useless-excludes`.
+    - #2998 PR by @mxr.
+    - #2935 issue by @mxr.
+
+### Fixes
+- Use `time.monotonic()` for more accurate hook timing.
+    - #3024 PR by @adamchainz.
+
+### Updating
+- Require npm 6.x+ for `language: node` hooks.
+    - #2996 PR by @RoelAdriaans.
+    - #1983 issue by @henryiii.
+
+3.4.0 - 2023-09-02
+==================
+
+### Features
+- Add `language: haskell`.
+    - #2932 by @alunduil.
+- Improve cpu count detection when run under cgroups.
+    - #2979 PR by @jdb8.
+    - #2978 issue by @jdb8.
+
+### Fixes
+- Handle negative exit codes from hooks receiving posix signals.
+    - #2971 PR by @chriskuehl.
+    - #2970 issue by @chriskuehl.
+
+3.3.3 - 2023-06-13
+==================
+
+### Fixes
+- Work around OS packagers setting `--install-dir` / `--bin-dir` in gem settings.
+    - #2905 PR by @jaysoffian.
+    - #2799 issue by @lmilbaum.
+
+3.3.2 - 2023-05-17
+==================
+
+### Fixes
+- Work around `r` on windows sometimes double-un-quoting arguments.
+    - #2885 PR by @lorenzwalthert.
+    - #2870 issue by @lorenzwalthert.
+
+3.3.1 - 2023-05-02
+==================
+
+### Fixes
+- Work around `git` partial clone bug for `autoupdate` on windows.
+    - #2866 PR by @asottile.
+    - #2865 issue by @adehad.
+
+3.3.0 - 2023-05-01
+==================
+
+### Features
+- Upgrade ruby-build.
+    - #2846 PR by @jalessio.
+- Use blobless clone for faster autoupdate.
+    - #2859 PR by @asottile.
+- Add `-j` / `--jobs` argument to `autoupdate` for parallel execution.
+    - #2863 PR by @asottile.
+    - issue by @gaborbernat.
+
+3.2.2 - 2023-04-03
+==================
+
+### Fixes
+- Fix support for swift >= 5.8.
+    - #2836 PR by @edelabar.
+    - #2835 issue by @kgrobelny-intive.
+
+3.2.1 - 2023-03-25
+==================
+
+### Fixes
+- Fix `language_version` for `language: rust` without global `rustup`.
+    - #2823 issue by @daschuer.
+    - #2827 PR by @asottile.
+
+3.2.0 - 2023-03-17
+==================
+
+### Features
+- Allow `pre-commit`, `pre-push`, and `pre-merge-commit` as `stages`.
+    - #2732 issue by @asottile.
+    - #2808 PR by @asottile.
+- Add `pre-rebase` hook support.
+    - #2582 issue by @BrutalSimplicity.
+    - #2725 PR by @mgaligniana.
+
+### Fixes
+- Remove bulky cargo cache from `language: rust` installs.
+    - #2820 PR by @asottile.
+
+3.1.1 - 2023-02-27
+==================
+
+### Fixes
+- Fix `rust` with `language_version` and a non-writable host `RUSTUP_HOME`.
+    - pre-commit-ci/issues#173 by @Swiftb0y.
+    - #2788 by @asottile.
+
+3.1.0 - 2023-02-22
+==================
+
+### Fixes
+- Fix `dotnet` for `.sln`-based hooks for dotnet>=7.0.200.
+    - #2763 PR by @m-rsha.
+- Prevent stashing when `diff` fails to execute.
+    - #2774 PR by @asottile.
+    - #2773 issue by @strubbly.
+- Dependencies are no longer sorted in repository key.
+    - #2776 PR by @asottile.
+
+### Updating
+- Deprecate `language: python_venv`.  Use `language: python` instead.
+    - #2746 PR by @asottile.
+    - #2734 issue by @asottile.
+
+
+3.0.4 - 2023-02-03
+==================
+
+### Fixes
+- Fix hook diff detection for files affected by `--textconv`.
+    - #2743 PR by @adamchainz.
+    - #2743 issue by @adamchainz.
+
+3.0.3 - 2023-02-01
+==================
+
+### Fixes
+- Revert "Prevent local `Gemfile` from interfering with hook execution.".
+    - #2739 issue by @Roguelazer.
+    - #2740 PR by @asottile.
+
 3.0.2 - 2023-01-29
 ==================
 

CONTRIBUTING.md

@@ -64,10 +64,10 @@ to implement.  The current implemented languages are at varying levels:
 - 0th class - pre-commit does not require any dependencies for these languages
   as they're not actually languages (current examples: fail, pygrep)
 - 1st class - pre-commit will bootstrap a full interpreter requiring nothing to
-  be installed globally (current examples: node, ruby, rust)
+  be installed globally (current examples: go, node, ruby, rust)
 - 2nd class - pre-commit requires the user to install the language globally but
-  will install tools in an isolated fashion (current examples: python, go,
+  will install tools in an isolated fashion (current examples: python, swift,
-  swift, docker).
+  docker).
 - 3rd class - pre-commit requires the user to install both the tool and the
   language globally (current examples: script, system)
 
@@ -92,7 +92,7 @@ language, for example:
 
 here are the apis that should be implemented for a language
 
-Note that these are also documented in [`pre_commit/languages/all.py`](https://github.com/pre-commit/pre-commit/blob/main/pre_commit/languages/all.py)
+Note that these are also documented in [`pre_commit/lang_base.py`](https://github.com/pre-commit/pre-commit/blob/main/pre_commit/lang_base.py)
 
 #### `ENVIRONMENT_DIR`
 
@@ -111,7 +111,7 @@ one cannot be determined, return `'default'`.
 You generally don't need to implement this on a first pass and can just use:
 
 ```python
-get_default_version = helpers.basic_default_version
+get_default_version = lang_base.basic_default_version
 ```
 
 `python` is currently the only language which implements this api
@@ -125,7 +125,7 @@ healthy.
 You generally don't need to implement this on a first pass and can just use:
 
 ```python
-health_check = helpers.basic_healthy_check
+health_check = lang_base.basic_health_check
 ```
 
 `python` is currently the only language which implements this api, for python
@@ -137,7 +137,7 @@ this is the trickiest one to implement and where all the smart parts happen.
 
 this api should do the following things
 
-- (0th / 3rd class): `install_environment = helpers.no_install`
+- (0th / 3rd class): `install_environment = lang_base.no_install`
 - (1st class): install a language runtime into the hook's directory
 - (2nd class): install the package at `.` into the `ENVIRONMENT_DIR`
 - (2nd class, optional): install packages listed in `additional_dependencies`

pre_commit/all_languages.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pre_commit.lang_base import Language
+from pre_commit.languages import conda
+from pre_commit.languages import coursier
+from pre_commit.languages import dart
+from pre_commit.languages import docker
+from pre_commit.languages import docker_image
+from pre_commit.languages import dotnet
+from pre_commit.languages import fail
+from pre_commit.languages import golang
+from pre_commit.languages import haskell
+from pre_commit.languages import julia
+from pre_commit.languages import lua
+from pre_commit.languages import node
+from pre_commit.languages import perl
+from pre_commit.languages import pygrep
+from pre_commit.languages import python
+from pre_commit.languages import r
+from pre_commit.languages import ruby
+from pre_commit.languages import rust
+from pre_commit.languages import swift
+from pre_commit.languages import unsupported
+from pre_commit.languages import unsupported_script
+
+
+languages: dict[str, Language] = {
+    'conda': conda,
+    'coursier': coursier,
+    'dart': dart,
+    'docker': docker,
+    'docker_image': docker_image,
+    'dotnet': dotnet,
+    'fail': fail,
+    'golang': golang,
+    'haskell': haskell,
+    'julia': julia,
+    'lua': lua,
+    'node': node,
+    'perl': perl,
+    'pygrep': pygrep,
+    'python': python,
+    'r': r,
+    'ruby': ruby,
+    'rust': rust,
+    'swift': swift,
+    'unsupported': unsupported,
+    'unsupported_script': unsupported_script,
+}
+language_names = sorted(languages)

pre_commit/clientlib.py

@@ -2,24 +2,42 @@ from __future__ import annotations
 
 import functools
 import logging
+import os.path
 import re
 import shlex
 import sys
+from collections.abc import Callable
+from collections.abc import Sequence
 from typing import Any
-from typing import Sequence
+from typing import NamedTuple
 
 import cfgv
 from identify.identify import ALL_TAGS
 
 import pre_commit.constants as C
+from pre_commit.all_languages import language_names
 from pre_commit.errors import FatalError
-from pre_commit.languages.all import all_languages
 from pre_commit.yaml import yaml_load
 
 logger = logging.getLogger('pre_commit')
 
 check_string_regex = cfgv.check_and(cfgv.check_string, cfgv.check_regex)
 
+HOOK_TYPES = (
+    'commit-msg',
+    'post-checkout',
+    'post-commit',
+    'post-merge',
+    'post-rewrite',
+    'pre-commit',
+    'pre-merge-commit',
+    'pre-push',
+    'pre-rebase',
+    'prepare-commit-msg',
+)
+# `manual` is not invoked by any installed git hook.  See #719
+STAGES = (*HOOK_TYPES, 'manual')
+
 
 def check_type_tag(tag: str) -> None:
     if tag not in ALL_TAGS:
@@ -43,13 +61,186 @@ def check_min_version(version: str) -> None:
         )
 
 
+_STAGES = {
+    'commit': 'pre-commit',
+    'merge-commit': 'pre-merge-commit',
+    'push': 'pre-push',
+}
+
+
+def transform_stage(stage: str) -> str:
+    return _STAGES.get(stage, stage)
+
+
+MINIMAL_MANIFEST_SCHEMA = cfgv.Array(
+    cfgv.Map(
+        'Hook', 'id',
+        cfgv.Required('id', cfgv.check_string),
+        cfgv.Optional('stages', cfgv.check_array(cfgv.check_string), []),
+    ),
+)
+
+
+def warn_for_stages_on_repo_init(repo: str, directory: str) -> None:
+    try:
+        manifest = cfgv.load_from_filename(
+            os.path.join(directory, C.MANIFEST_FILE),
+            schema=MINIMAL_MANIFEST_SCHEMA,
+            load_strategy=yaml_load,
+            exc_tp=InvalidManifestError,
+        )
+    except InvalidManifestError:
+        return  # they'll get a better error message when it actually loads!
+
+    legacy_stages = {}  # sorted set
+    for hook in manifest:
+        for stage in hook.get('stages', ()):
+            if stage in _STAGES:
+                legacy_stages[stage] = True
+
+    if legacy_stages:
+        logger.warning(
+            f'repo `{repo}` uses deprecated stage names '
+            f'({", ".join(legacy_stages)}) which will be removed in a '
+            f'future version.  '
+            f'Hint: often `pre-commit autoupdate --repo {shlex.quote(repo)}` '
+            f'will fix this.  '
+            f'if it does not -- consider reporting an issue to that repo.',
+        )
+
+
+class StagesMigrationNoDefault(NamedTuple):
+    key: str
+    default: Sequence[str]
+
+    def check(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+
+        with cfgv.validate_context(f'At key: {self.key}'):
+            val = dct[self.key]
+            cfgv.check_array(cfgv.check_any)(val)
+
+            val = [transform_stage(v) for v in val]
+            cfgv.check_array(cfgv.check_one_of(STAGES))(val)
+
+    def apply_default(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+        dct[self.key] = [transform_stage(v) for v in dct[self.key]]
+
+    def remove_default(self, dct: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+
+class StagesMigration(StagesMigrationNoDefault):
+    def apply_default(self, dct: dict[str, Any]) -> None:
+        dct.setdefault(self.key, self.default)
+        super().apply_default(dct)
+
+
+class DeprecatedStagesWarning(NamedTuple):
+    key: str
+
+    def check(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+
+        val = dct[self.key]
+        cfgv.check_array(cfgv.check_any)(val)
+
+        legacy_stages = [stage for stage in val if stage in _STAGES]
+        if legacy_stages:
+            logger.warning(
+                f'hook id `{dct["id"]}` uses deprecated stage names '
+                f'({", ".join(legacy_stages)}) which will be removed in a '
+                f'future version.  '
+                f'run: `pre-commit migrate-config` to automatically fix this.',
+            )
+
+    def apply_default(self, dct: dict[str, Any]) -> None:
+        pass
+
+    def remove_default(self, dct: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+
+class DeprecatedDefaultStagesWarning(NamedTuple):
+    key: str
+
+    def check(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+
+        val = dct[self.key]
+        cfgv.check_array(cfgv.check_any)(val)
+
+        legacy_stages = [stage for stage in val if stage in _STAGES]
+        if legacy_stages:
+            logger.warning(
+                f'top-level `default_stages` uses deprecated stage names '
+                f'({", ".join(legacy_stages)}) which will be removed in a '
+                f'future version.  '
+                f'run: `pre-commit migrate-config` to automatically fix this.',
+            )
+
+    def apply_default(self, dct: dict[str, Any]) -> None:
+        pass
+
+    def remove_default(self, dct: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+
+def _translate_language(name: str) -> str:
+    return {
+        'system': 'unsupported',
+        'script': 'unsupported_script',
+    }.get(name, name)
+
+
+class LanguageMigration(NamedTuple):  # remove
+    key: str
+    check_fn: Callable[[object], None]
+
+    def check(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+
+        with cfgv.validate_context(f'At key: {self.key}'):
+            self.check_fn(_translate_language(dct[self.key]))
+
+    def apply_default(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            return
+
+        dct[self.key] = _translate_language(dct[self.key])
+
+    def remove_default(self, dct: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+
+class LanguageMigrationRequired(LanguageMigration):  # replace with Required
+    def check(self, dct: dict[str, Any]) -> None:
+        if self.key not in dct:
+            raise cfgv.ValidationError(f'Missing required key: {self.key}')
+
+        super().check(dct)
+
+
 MANIFEST_HOOK_DICT = cfgv.Map(
     'Hook', 'id',
 
+    # check first in case it uses some newer, incompatible feature
+    cfgv.Optional(
+        'minimum_pre_commit_version',
+        cfgv.check_and(cfgv.check_string, check_min_version),
+        '0',
+    ),
+
     cfgv.Required('id', cfgv.check_string),
     cfgv.Required('name', cfgv.check_string),
     cfgv.Required('entry', cfgv.check_string),
-    cfgv.Required('language', cfgv.check_one_of(all_languages)),
+    LanguageMigrationRequired('language', cfgv.check_one_of(language_names)),
     cfgv.Optional('alias', cfgv.check_string, ''),
 
     cfgv.Optional('files', check_string_regex, ''),
@@ -68,9 +259,8 @@ MANIFEST_HOOK_DICT = cfgv.Map(
     cfgv.Optional('description', cfgv.check_string, ''),
     cfgv.Optional('language_version', cfgv.check_string, C.DEFAULT),
     cfgv.Optional('log_file', cfgv.check_string, ''),
-    cfgv.Optional('minimum_pre_commit_version', cfgv.check_string, '0'),
     cfgv.Optional('require_serial', cfgv.check_bool, False),
-    cfgv.Optional('stages', cfgv.check_array(cfgv.check_one_of(C.STAGES)), []),
+    StagesMigration('stages', []),
     cfgv.Optional('verbose', cfgv.check_bool, False),
 )
 MANIFEST_SCHEMA = cfgv.Array(MANIFEST_HOOK_DICT)
@@ -80,10 +270,19 @@ class InvalidManifestError(FatalError):
     pass
 
 
+def _load_manifest_forward_compat(contents: str) -> object:
+    obj = yaml_load(contents)
+    if isinstance(obj, dict):
+        check_min_version('5')
+        raise AssertionError('unreachable')
+    else:
+        return obj
+
+
 load_manifest = functools.partial(
     cfgv.load_from_filename,
     schema=MANIFEST_SCHEMA,
-    load_strategy=yaml_load,
+    load_strategy=_load_manifest_forward_compat,
     exc_tp=InvalidManifestError,
 )
 
@@ -205,12 +404,20 @@ class NotAllowed(cfgv.OptionalNoDefault):
             raise cfgv.ValidationError(f'{self.key!r} cannot be overridden')
 
 
+_COMMON_HOOK_WARNINGS = (
+    OptionalSensibleRegexAtHook('files', cfgv.check_string),
+    OptionalSensibleRegexAtHook('exclude', cfgv.check_string),
+    DeprecatedStagesWarning('stages'),
+)
+
 META_HOOK_DICT = cfgv.Map(
     'Hook', 'id',
     cfgv.Required('id', cfgv.check_string),
     cfgv.Required('id', cfgv.check_one_of(tuple(k for k, _ in _meta))),
-    # language must be system
+    # language must be `unsupported`
-    cfgv.Optional('language', cfgv.check_one_of({'system'}), 'system'),
+    cfgv.Optional(
+        'language', cfgv.check_one_of({'unsupported'}), 'unsupported',
+    ),
     # entry cannot be overridden
     NotAllowed('entry', cfgv.check_any),
     *(
@@ -227,6 +434,7 @@ META_HOOK_DICT = cfgv.Map(
         item
         for item in MANIFEST_HOOK_DICT.items
     ),
+    *_COMMON_HOOK_WARNINGS,
 )
 CONFIG_HOOK_DICT = cfgv.Map(
     'Hook', 'id',
@@ -241,17 +449,18 @@ CONFIG_HOOK_DICT = cfgv.Map(
         cfgv.OptionalNoDefault(item.key, item.check_fn)
         for item in MANIFEST_HOOK_DICT.items
         if item.key != 'id'
+        if item.key != 'stages'
+        if item.key != 'language'  # remove
     ),
-    OptionalSensibleRegexAtHook('files', cfgv.check_string),
+    StagesMigrationNoDefault('stages', []),
-    OptionalSensibleRegexAtHook('exclude', cfgv.check_string),
+    LanguageMigration('language', cfgv.check_one_of(language_names)),  # remove
+    *_COMMON_HOOK_WARNINGS,
 )
 LOCAL_HOOK_DICT = cfgv.Map(
     'Hook', 'id',
 
     *MANIFEST_HOOK_DICT.items,
-
+    *_COMMON_HOOK_WARNINGS,
-    OptionalSensibleRegexAtHook('files', cfgv.check_string),
-    OptionalSensibleRegexAtHook('exclude', cfgv.check_string),
 )
 CONFIG_REPO_DICT = cfgv.Map(
     'Repository', 'repo',
@@ -281,34 +490,33 @@ CONFIG_REPO_DICT = cfgv.Map(
 )
 DEFAULT_LANGUAGE_VERSION = cfgv.Map(
     'DefaultLanguageVersion', None,
-    cfgv.NoAdditionalKeys(all_languages),
+    cfgv.NoAdditionalKeys(language_names),
-    *(cfgv.Optional(x, cfgv.check_string, C.DEFAULT) for x in all_languages),
+    *(cfgv.Optional(x, cfgv.check_string, C.DEFAULT) for x in language_names),
 )
 CONFIG_SCHEMA = cfgv.Map(
     'Config', None,
 
-    cfgv.RequiredRecurse('repos', cfgv.Array(CONFIG_REPO_DICT)),
+    # check first in case it uses some newer, incompatible feature
-    cfgv.Optional(
-        'default_install_hook_types',
-        cfgv.check_array(cfgv.check_one_of(C.HOOK_TYPES)),
-        ['pre-commit'],
-    ),
-    cfgv.OptionalRecurse(
-        'default_language_version', DEFAULT_LANGUAGE_VERSION, {},
-    ),
-    cfgv.Optional(
-        'default_stages',
-        cfgv.check_array(cfgv.check_one_of(C.STAGES)),
-        C.STAGES,
-    ),
-    cfgv.Optional('files', check_string_regex, ''),
-    cfgv.Optional('exclude', check_string_regex, '^$'),
-    cfgv.Optional('fail_fast', cfgv.check_bool, False),
     cfgv.Optional(
         'minimum_pre_commit_version',
         cfgv.check_and(cfgv.check_string, check_min_version),
         '0',
     ),
+
+    cfgv.RequiredRecurse('repos', cfgv.Array(CONFIG_REPO_DICT)),
+    cfgv.Optional(
+        'default_install_hook_types',
+        cfgv.check_array(cfgv.check_one_of(HOOK_TYPES)),
+        ['pre-commit'],
+    ),
+    cfgv.OptionalRecurse(
+        'default_language_version', DEFAULT_LANGUAGE_VERSION, {},
+    ),
+    StagesMigration('default_stages', STAGES),
+    DeprecatedDefaultStagesWarning('default_stages'),
+    cfgv.Optional('files', check_string_regex, ''),
+    cfgv.Optional('exclude', check_string_regex, '^$'),
+    cfgv.Optional('fail_fast', cfgv.check_bool, False),
     cfgv.WarnAdditionalKeys(
         (
             'repos',

pre_commit/commands/autoupdate.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
+import concurrent.futures
 import os.path
 import re
 import tempfile
+from collections.abc import Sequence
 from typing import Any
 from typing import NamedTuple
-from typing import Sequence
 
 import pre_commit.constants as C
 from pre_commit import git
 from pre_commit import output
+from pre_commit import xargs
 from pre_commit.clientlib import InvalidManifestError
 from pre_commit.clientlib import load_config
 from pre_commit.clientlib import load_manifest
 from pre_commit.clientlib import LOCAL
 from pre_commit.clientlib import META
 from pre_commit.commands.migrate_config import migrate_config
-from pre_commit.store import Store
 from pre_commit.util import CalledProcessError
 from pre_commit.util import cmd_output
 from pre_commit.util import cmd_output_b
@@ -27,49 +28,58 @@ from pre_commit.yaml import yaml_load
 class RevInfo(NamedTuple):
     repo: str
     rev: str
-    frozen: str | None
+    frozen: str | None = None
+    hook_ids: frozenset[str] = frozenset()
 
     @classmethod
     def from_config(cls, config: dict[str, Any]) -> RevInfo:
-        return cls(config['repo'], config['rev'], None)
+        return cls(config['repo'], config['rev'])
 
     def update(self, tags_only: bool, freeze: bool) -> RevInfo:
-        git_cmd = ('git', *git.NO_FS_MONITOR)
-
-        if tags_only:
-            tag_cmd = (
-                *git_cmd, 'describe',
-                'FETCH_HEAD', '--tags', '--abbrev=0',
-            )
-        else:
-            tag_cmd = (
-                *git_cmd, 'describe',
-                'FETCH_HEAD', '--tags', '--exact',
-            )
-
         with tempfile.TemporaryDirectory() as tmp:
+            _git = ('git', *git.NO_FS_MONITOR, '-C', tmp)
+
+            if tags_only:
+                tag_opt = '--abbrev=0'
+            else:
+                tag_opt = '--exact'
+            tag_cmd = (*_git, 'describe', 'FETCH_HEAD', '--tags', tag_opt)
+
             git.init_repo(tmp, self.repo)
+            cmd_output_b(*_git, 'config', 'extensions.partialClone', 'true')
             cmd_output_b(
-                *git_cmd, 'fetch', 'origin', 'HEAD', '--tags',
+                *_git, 'fetch', 'origin', 'HEAD',
-                cwd=tmp,
+                '--quiet', '--filter=blob:none', '--tags',
             )
 
             try:
-                rev = cmd_output(*tag_cmd, cwd=tmp)[1].strip()
+                rev = cmd_output(*tag_cmd)[1].strip()
             except CalledProcessError:
-                cmd = (*git_cmd, 'rev-parse', 'FETCH_HEAD')
+                rev = cmd_output(*_git, 'rev-parse', 'FETCH_HEAD')[1].strip()
-                rev = cmd_output(*cmd, cwd=tmp)[1].strip()
             else:
                 if tags_only:
                     rev = git.get_best_candidate_tag(rev, tmp)
 
             frozen = None
             if freeze:
-                exact_rev_cmd = (*git_cmd, 'rev-parse', rev)
+                exact = cmd_output(*_git, 'rev-parse', rev)[1].strip()
-                exact = cmd_output(*exact_rev_cmd, cwd=tmp)[1].strip()
                 if exact != rev:
                     rev, frozen = exact, rev
-        return self._replace(rev=rev, frozen=frozen)
+
+            try:
+                # workaround for windows -- see #2865
+                cmd_output_b(*_git, 'show', f'{rev}:{C.MANIFEST_FILE}')
+                cmd_output(*_git, 'checkout', rev, '--', C.MANIFEST_FILE)
+            except CalledProcessError:
+                pass  # this will be caught by manifest validating code
+            try:
+                manifest = load_manifest(os.path.join(tmp, C.MANIFEST_FILE))
+            except InvalidManifestError as e:
+                raise RepositoryCannotBeUpdatedError(f'[{self.repo}] {e}')
+            else:
+                hook_ids = frozenset(hook['id'] for hook in manifest)
+
+        return self._replace(rev=rev, frozen=frozen, hook_ids=hook_ids)
 
 
 class RepositoryCannotBeUpdatedError(RuntimeError):
@@ -79,24 +89,30 @@ class RepositoryCannotBeUpdatedError(RuntimeError):
 def _check_hooks_still_exist_at_rev(
         repo_config: dict[str, Any],
         info: RevInfo,
-        store: Store,
 ) -> None:
-    try:
-        path = store.clone(repo_config['repo'], info.rev)
-        manifest = load_manifest(os.path.join(path, C.MANIFEST_FILE))
-    except InvalidManifestError as e:
-        raise RepositoryCannotBeUpdatedError(str(e))
-
     # See if any of our hooks were deleted with the new commits
     hooks = {hook['id'] for hook in repo_config['hooks']}
-    hooks_missing = hooks - {hook['id'] for hook in manifest}
+    hooks_missing = hooks - info.hook_ids
     if hooks_missing:
         raise RepositoryCannotBeUpdatedError(
-            f'Cannot update because the update target is missing these '
+            f'[{info.repo}] Cannot update because the update target is '
-            f'hooks:\n{", ".join(sorted(hooks_missing))}',
+            f'missing these hooks: {", ".join(sorted(hooks_missing))}',
         )
 
 
+def _update_one(
+        i: int,
+        repo: dict[str, Any],
+        *,
+        tags_only: bool,
+        freeze: bool,
+) -> tuple[int, RevInfo, RevInfo]:
+    old = RevInfo.from_config(repo)
+    new = old.update(tags_only=tags_only, freeze=freeze)
+    _check_hooks_still_exist_at_rev(repo, new)
+    return i, old, new
+
+
 REV_LINE_RE = re.compile(r'^(\s+)rev:(\s*)([\'"]?)([^\s#]+)(.*)(\r?\n)$')
 
 
@@ -145,49 +161,53 @@ def _write_new_config(path: str, rev_infos: list[RevInfo | None]) -> None:
 
 def autoupdate(
         config_file: str,
-        store: Store,
         tags_only: bool,
         freeze: bool,
         repos: Sequence[str] = (),
+        jobs: int = 1,
 ) -> int:
     """Auto-update the pre-commit config to the latest versions of repos."""
     migrate_config(config_file, quiet=True)
-    retv = 0
-    rev_infos: list[RevInfo | None] = []
     changed = False
+    retv = 0
 
-    config = load_config(config_file)
+    config_repos = [
-    for repo_config in config['repos']:
+        repo for repo in load_config(config_file)['repos']
-        if repo_config['repo'] in {LOCAL, META}:
+        if repo['repo'] not in {LOCAL, META}
-            continue
+    ]
 
-        info = RevInfo.from_config(repo_config)
+    rev_infos: list[RevInfo | None] = [None] * len(config_repos)
-        if repos and info.repo not in repos:
+    jobs = jobs or xargs.cpu_count()  # 0 => number of cpus
-            rev_infos.append(None)
+    jobs = min(jobs, len(repos) or len(config_repos))  # max 1-per-thread
-            continue
+    jobs = max(jobs, 1)  # at least one thread
-
+    with concurrent.futures.ThreadPoolExecutor(jobs) as exe:
-        output.write(f'Updating {info.repo} ... ')
+        futures = [
-        new_info = info.update(tags_only=tags_only, freeze=freeze)
+            exe.submit(
-        try:
+                _update_one,
-            _check_hooks_still_exist_at_rev(repo_config, new_info, store)
+                i, repo, tags_only=tags_only, freeze=freeze,
-        except RepositoryCannotBeUpdatedError as error:
+            )
-            output.write_line(error.args[0])
+            for i, repo in enumerate(config_repos)
-            rev_infos.append(None)
+            if not repos or repo['repo'] in repos
-            retv = 1
+        ]
-            continue
+        for future in concurrent.futures.as_completed(futures):
-
+            try:
-        if new_info.rev != info.rev:
+                i, old, new = future.result()
-            changed = True
+            except RepositoryCannotBeUpdatedError as e:
-            if new_info.frozen:
+                output.write_line(str(e))
-                updated_to = f'{new_info.frozen} (frozen)'
+                retv = 1
             else:
-                updated_to = new_info.rev
+                if new.rev != old.rev:
-            msg = f'updating {info.rev} -> {updated_to}.'
+                    changed = True
-            output.write_line(msg)
+                    if new.frozen:
-            rev_infos.append(new_info)
+                        new_s = f'{new.frozen} (frozen)'
-        else:
+                    else:
-            output.write_line('already up to date.')
+                        new_s = new.rev
-            rev_infos.append(None)
+                    msg = f'updating {old.rev} -> {new_s}'
+                    rev_infos[i] = new
+                else:
+                    msg = 'already up to date!'
+
+                output.write_line(f'[{old.repo}] {msg}')
 
     if changed:
         _write_new_config(config_file, rev_infos)

pre_commit/commands/gc.py

@@ -12,6 +12,7 @@ from pre_commit.clientlib import load_manifest
 from pre_commit.clientlib import LOCAL
 from pre_commit.clientlib import META
 from pre_commit.store import Store
+from pre_commit.util import rmtree
 
 
 def _mark_used_repos(
@@ -26,7 +27,8 @@ def _mark_used_repos(
         for hook in repo['hooks']:
             deps = hook.get('additional_dependencies')
             unused_repos.discard((
-                store.db_repo_name(repo['repo'], deps), C.LOCAL_REPO_VERSION,
+                store.db_repo_name(repo['repo'], deps),
+                C.LOCAL_REPO_VERSION,
             ))
     else:
         key = (repo['repo'], repo['rev'])
@@ -56,34 +58,41 @@ def _mark_used_repos(
             ))
 
 
-def _gc_repos(store: Store) -> int:
+def _gc(store: Store) -> int:
-    configs = store.select_all_configs()
+    with store.exclusive_lock(), store.connect() as db:
-    repos = store.select_all_repos()
+        store._create_configs_table(db)
 
-    # delete config paths which do not exist
+        repos = db.execute('SELECT repo, ref, path FROM repos').fetchall()
-    dead_configs = [p for p in configs if not os.path.exists(p)]
+        all_repos = {(repo, ref): path for repo, ref, path in repos}
-    live_configs = [p for p in configs if os.path.exists(p)]
+        unused_repos = set(all_repos)
 
-    all_repos = {(repo, ref): path for repo, ref, path in repos}
+        configs_rows = db.execute('SELECT path FROM configs').fetchall()
-    unused_repos = set(all_repos)
+        configs = [path for path, in configs_rows]
-    for config_path in live_configs:
-        try:
-            config = load_config(config_path)
-        except InvalidConfigError:
-            dead_configs.append(config_path)
-            continue
-        else:
-            for repo in config['repos']:
-                _mark_used_repos(store, all_repos, unused_repos, repo)
 
-    store.delete_configs(dead_configs)
+        dead_configs = []
-    for db_repo_name, ref in unused_repos:
+        for config_path in configs:
-        store.delete_repo(db_repo_name, ref, all_repos[(db_repo_name, ref)])
+            try:
-    return len(unused_repos)
+                config = load_config(config_path)
+            except InvalidConfigError:
+                dead_configs.append(config_path)
+                continue
+            else:
+                for repo in config['repos']:
+                    _mark_used_repos(store, all_repos, unused_repos, repo)
+
+        paths = [(path,) for path in dead_configs]
+        db.executemany('DELETE FROM configs WHERE path = ?', paths)
+
+        db.executemany(
+            'DELETE FROM repos WHERE repo = ? and ref = ?',
+            sorted(unused_repos),
+        )
+        for k in unused_repos:
+            rmtree(all_repos[k])
+
+        return len(unused_repos)
 
 
 def gc(store: Store) -> int:
-    with store.exclusive_lock():
+    output.write_line(f'{_gc(store)} repo(s) removed.')
-        repos_removed = _gc_repos(store)
-    output.write_line(f'{repos_removed} repo(s) removed.')
     return 0

pre_commit/commands/hazmat.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+from collections.abc import Sequence
+
+from pre_commit.parse_shebang import normalize_cmd
+
+
+def add_parsers(parser: argparse.ArgumentParser) -> None:
+    subparsers = parser.add_subparsers(dest='tool')
+
+    cd_parser = subparsers.add_parser(
+        'cd', help='cd to a subdir and run the command',
+    )
+    cd_parser.add_argument('subdir')
+    cd_parser.add_argument('cmd', nargs=argparse.REMAINDER)
+
+    ignore_exit_code_parser = subparsers.add_parser(
+        'ignore-exit-code', help='run the command but ignore the exit code',
+    )
+    ignore_exit_code_parser.add_argument('cmd', nargs=argparse.REMAINDER)
+
+    n1_parser = subparsers.add_parser(
+        'n1', help='run the command once per filename',
+    )
+    n1_parser.add_argument('cmd', nargs=argparse.REMAINDER)
+
+
+def _cmd_filenames(cmd: tuple[str, ...]) -> tuple[
+    tuple[str, ...],
+    tuple[str, ...],
+]:
+    for idx, val in enumerate(reversed(cmd)):
+        if val == '--':
+            split = len(cmd) - idx
+            break
+    else:
+        raise SystemExit('hazmat entry must end with `--`')
+
+    return cmd[:split - 1], cmd[split:]
+
+
+def cd(subdir: str, cmd: tuple[str, ...]) -> int:
+    cmd, filenames = _cmd_filenames(cmd)
+
+    prefix = f'{subdir}/'
+    new_filenames = []
+    for filename in filenames:
+        if not filename.startswith(prefix):
+            raise SystemExit(f'unexpected file without {prefix=}: {filename}')
+        else:
+            new_filenames.append(filename.removeprefix(prefix))
+
+    cmd = normalize_cmd(cmd)
+    return subprocess.call((*cmd, *new_filenames), cwd=subdir)
+
+
+def ignore_exit_code(cmd: tuple[str, ...]) -> int:
+    cmd = normalize_cmd(cmd)
+    subprocess.call(cmd)
+    return 0
+
+
+def n1(cmd: tuple[str, ...]) -> int:
+    cmd, filenames = _cmd_filenames(cmd)
+    cmd = normalize_cmd(cmd)
+    ret = 0
+    for filename in filenames:
+        ret |= subprocess.call((*cmd, filename))
+    return ret
+
+
+def impl(args: argparse.Namespace) -> int:
+    args.cmd = tuple(args.cmd)
+    if args.tool == 'cd':
+        return cd(args.subdir, args.cmd)
+    elif args.tool == 'ignore-exit-code':
+        return ignore_exit_code(args.cmd)
+    elif args.tool == 'n1':
+        return n1(args.cmd)
+    else:
+        raise NotImplementedError(f'unexpected tool: {args.tool}')
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    add_parsers(parser)
+    args = parser.parse_args(argv)
+
+    return impl(args)
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

pre_commit/commands/hook_impl.py

@@ -4,7 +4,7 @@ import argparse
 import os.path
 import subprocess
 import sys
-from typing import Sequence
+from collections.abc import Sequence
 
 from pre_commit.commands.run import run
 from pre_commit.envcontext import envcontext
@@ -73,6 +73,8 @@ def _ns(
         local_branch: str | None = None,
         from_ref: str | None = None,
         to_ref: str | None = None,
+        pre_rebase_upstream: str | None = None,
+        pre_rebase_branch: str | None = None,
         remote_name: str | None = None,
         remote_url: str | None = None,
         commit_msg_filename: str | None = None,
@@ -84,11 +86,13 @@ def _ns(
 ) -> argparse.Namespace:
     return argparse.Namespace(
         color=color,
-        hook_stage=hook_type.replace('pre-', ''),
+        hook_stage=hook_type,
         remote_branch=remote_branch,
         local_branch=local_branch,
         from_ref=from_ref,
         to_ref=to_ref,
+        pre_rebase_upstream=pre_rebase_upstream,
+        pre_rebase_branch=pre_rebase_branch,
         remote_name=remote_name,
         remote_url=remote_url,
         commit_msg_filename=commit_msg_filename,
@@ -102,6 +106,7 @@ def _ns(
         hook=None,
         verbose=False,
         show_diff_on_failure=False,
+        fail_fast=False,
     )
 
 
@@ -185,6 +190,12 @@ def _check_args_length(hook_type: str, args: Sequence[str]) -> None:
                 f'hook-impl for {hook_type} expected 1, 2, or 3 arguments '
                 f'but got {len(args)}: {args}',
             )
+    elif hook_type == 'pre-rebase':
+        if len(args) < 1 or len(args) > 2:
+            raise SystemExit(
+                f'hook-impl for {hook_type} expected 1 or 2 arguments '
+                f'but got {len(args)}: {args}',
+            )
     elif hook_type in _EXPECTED_ARG_LENGTH_BY_HOOK:
         expected = _EXPECTED_ARG_LENGTH_BY_HOOK[hook_type]
         if len(args) != expected:
@@ -231,6 +242,13 @@ def _run_ns(
         return _ns(hook_type, color, is_squash_merge=args[0])
     elif hook_type == 'post-rewrite':
         return _ns(hook_type, color, rewrite_command=args[0])
+    elif hook_type == 'pre-rebase' and len(args) == 1:
+        return _ns(hook_type, color, pre_rebase_upstream=args[0])
+    elif hook_type == 'pre-rebase' and len(args) == 2:
+        return _ns(
+            hook_type, color, pre_rebase_upstream=args[0],
+            pre_rebase_branch=args[1],
+        )
     else:
         raise AssertionError(f'unexpected hook type: {hook_type}')
 

pre_commit/commands/install_uninstall.py

@@ -103,8 +103,7 @@ def _install_hook_script(
 
         hook_file.write(before + TEMPLATE_START)
         hook_file.write(f'INSTALL_PYTHON={shlex.quote(sys.executable)}\n')
-        # TODO: python3.8+: shlex.join
+        args_s = shlex.join(args)
-        args_s = ' '.join(shlex.quote(part) for part in args)
         hook_file.write(f'ARGS=({args_s})\n')
         hook_file.write(TEMPLATE_END + after)
     make_executable(hook_path)

pre_commit/commands/migrate_config.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
 
-import re
+import functools
+import itertools
 import textwrap
+from collections.abc import Callable
 
 import cfgv
 import yaml
+from yaml.nodes import ScalarNode
 
 from pre_commit.clientlib import InvalidConfigError
+from pre_commit.yaml import yaml_compose
 from pre_commit.yaml import yaml_load
+from pre_commit.yaml_rewrite import MappingKey
+from pre_commit.yaml_rewrite import MappingValue
+from pre_commit.yaml_rewrite import match
+from pre_commit.yaml_rewrite import SequenceItem
 
 
 def _is_header_line(line: str) -> bool:
@@ -38,8 +46,69 @@ def _migrate_map(contents: str) -> str:
     return contents
 
 
-def _migrate_sha_to_rev(contents: str) -> str:
+def _preserve_style(n: ScalarNode, *, s: str) -> str:
-    return re.sub(r'(\n\s+)sha:', r'\1rev:', contents)
+    style = n.style or ''
+    return f'{style}{s}{style}'
+
+
+def _fix_stage(n: ScalarNode) -> str:
+    return _preserve_style(n, s=f'pre-{n.value}')
+
+
+def _migrate_composed(contents: str) -> str:
+    tree = yaml_compose(contents)
+    rewrites: list[tuple[ScalarNode, Callable[[ScalarNode], str]]] = []
+
+    # sha -> rev
+    sha_to_rev_replace = functools.partial(_preserve_style, s='rev')
+    sha_to_rev_matcher = (
+        MappingValue('repos'),
+        SequenceItem(),
+        MappingKey('sha'),
+    )
+    for node in match(tree, sha_to_rev_matcher):
+        rewrites.append((node, sha_to_rev_replace))
+
+    # python_venv -> python
+    language_matcher = (
+        MappingValue('repos'),
+        SequenceItem(),
+        MappingValue('hooks'),
+        SequenceItem(),
+        MappingValue('language'),
+    )
+    python_venv_replace = functools.partial(_preserve_style, s='python')
+    for node in match(tree, language_matcher):
+        if node.value == 'python_venv':
+            rewrites.append((node, python_venv_replace))
+
+    # stages rewrites
+    default_stages_matcher = (MappingValue('default_stages'), SequenceItem())
+    default_stages_match = match(tree, default_stages_matcher)
+    hook_stages_matcher = (
+        MappingValue('repos'),
+        SequenceItem(),
+        MappingValue('hooks'),
+        SequenceItem(),
+        MappingValue('stages'),
+        SequenceItem(),
+    )
+    hook_stages_match = match(tree, hook_stages_matcher)
+    for node in itertools.chain(default_stages_match, hook_stages_match):
+        if node.value in {'commit', 'push', 'merge-commit'}:
+            rewrites.append((node, _fix_stage))
+
+    rewrites.sort(reverse=True, key=lambda nf: nf[0].start_mark.index)
+
+    src_parts = []
+    end: int | None = None
+    for node, func in rewrites:
+        src_parts.append(contents[node.end_mark.index:end])
+        src_parts.append(func(node))
+        end = node.start_mark.index
+    src_parts.append(contents[:end])
+    src_parts.reverse()
+    return ''.join(src_parts)
 
 
 def migrate_config(config_file: str, quiet: bool = False) -> int:
@@ -54,7 +123,7 @@ def migrate_config(config_file: str, quiet: bool = False) -> int:
                 raise cfgv.ValidationError(str(e))
 
     contents = _migrate_map(contents)
-    contents = _migrate_sha_to_rev(contents)
+    contents = _migrate_composed(contents)
 
     if contents != orig_contents:
         with open(config_file, 'w') as f:

pre_commit/commands/run.py

@@ -9,19 +9,20 @@ import re
 import subprocess
 import time
 import unicodedata
+from collections.abc import Generator
+from collections.abc import Iterable
+from collections.abc import MutableMapping
+from collections.abc import Sequence
 from typing import Any
-from typing import Collection
-from typing import MutableMapping
-from typing import Sequence
 
 from identify.identify import tags_from_path
 
 from pre_commit import color
 from pre_commit import git
 from pre_commit import output
+from pre_commit.all_languages import languages
 from pre_commit.clientlib import load_config
 from pre_commit.hook import Hook
-from pre_commit.languages.all import languages
 from pre_commit.repository import all_hooks
 from pre_commit.repository import install_hook_envs
 from pre_commit.staged_files_only import staged_files_only
@@ -57,37 +58,36 @@ def _full_msg(
 
 
 def filter_by_include_exclude(
-        names: Collection[str],
+        names: Iterable[str],
         include: str,
         exclude: str,
-) -> list[str]:
+) -> Generator[str]:
     include_re, exclude_re = re.compile(include), re.compile(exclude)
-    return [
+    return (
         filename for filename in names
         if include_re.search(filename)
         if not exclude_re.search(filename)
-    ]
+    )
 
 
 class Classifier:
-    def __init__(self, filenames: Collection[str]) -> None:
+    def __init__(self, filenames: Iterable[str]) -> None:
         self.filenames = [f for f in filenames if os.path.lexists(f)]
 
-    @functools.lru_cache(maxsize=None)
+    @functools.cache
     def _types_for_file(self, filename: str) -> set[str]:
         return tags_from_path(filename)
 
     def by_types(
             self,
-            names: Sequence[str],
+            names: Iterable[str],
-            types: Collection[str],
+            types: Iterable[str],
-            types_or: Collection[str],
+            types_or: Iterable[str],
-            exclude_types: Collection[str],
+            exclude_types: Iterable[str],
-    ) -> list[str]:
+    ) -> Generator[str]:
         types = frozenset(types)
         types_or = frozenset(types_or)
         exclude_types = frozenset(exclude_types)
-        ret = []
         for filename in names:
             tags = self._types_for_file(filename)
             if (
@@ -95,24 +95,24 @@ class Classifier:
                     (not types_or or tags & types_or) and
                     not tags & exclude_types
             ):
-                ret.append(filename)
+                yield filename
-        return ret
 
-    def filenames_for_hook(self, hook: Hook) -> tuple[str, ...]:
+    def filenames_for_hook(self, hook: Hook) -> Generator[str]:
-        names = self.filenames
+        return self.by_types(
-        names = filter_by_include_exclude(names, hook.files, hook.exclude)
+            filter_by_include_exclude(
-        names = self.by_types(
+                self.filenames,
-            names,
+                hook.files,
+                hook.exclude,
+            ),
             hook.types,
             hook.types_or,
             hook.exclude_types,
         )
-        return tuple(names)
 
     @classmethod
     def from_config(
             cls,
-            filenames: Collection[str],
+            filenames: Iterable[str],
             include: str,
             exclude: str,
     ) -> Classifier:
@@ -121,7 +121,7 @@ class Classifier:
         # this also makes improperly quoted shell-based hooks work better
         # see #1173
         if os.altsep == '/' and os.sep == '\\':
-            filenames = [f.replace(os.sep, os.altsep) for f in filenames]
+            filenames = (f.replace(os.sep, os.altsep) for f in filenames)
         filenames = filter_by_include_exclude(filenames, include, exclude)
         return Classifier(filenames)
 
@@ -148,7 +148,7 @@ def _run_single_hook(
         verbose: bool,
         use_color: bool,
 ) -> tuple[bool, bytes]:
-    filenames = classifier.filenames_for_hook(hook)
+    filenames = tuple(classifier.filenames_for_hook(hook))
 
     if hook.id in skips or hook.alias in skips:
         output.write(
@@ -187,7 +187,7 @@ def _run_single_hook(
 
         if not hook.pass_filenames:
             filenames = ()
-        time_before = time.time()
+        time_before = time.monotonic()
         language = languages[hook.language]
         with language.in_env(hook.prefix, hook.language_version):
             retcode, out = language.run_hook(
@@ -199,7 +199,7 @@ def _run_single_hook(
                 require_serial=hook.require_serial,
                 color=use_color,
             )
-        duration = round(time.time() - time_before, 2) or 0
+        duration = round(time.monotonic() - time_before, 2) or 0
         diff_after = _get_diff()
 
         # if the hook makes changes, fail the commit
@@ -250,10 +250,11 @@ def _compute_cols(hooks: Sequence[Hook]) -> int:
     return max(cols, 80)
 
 
-def _all_filenames(args: argparse.Namespace) -> Collection[str]:
+def _all_filenames(args: argparse.Namespace) -> Iterable[str]:
     # these hooks do not operate on files
     if args.hook_stage in {
         'post-checkout', 'post-commit', 'post-merge', 'post-rewrite',
+        'pre-rebase',
     }:
         return ()
     elif args.hook_stage in {'prepare-commit-msg', 'commit-msg'}:
@@ -272,7 +273,8 @@ def _all_filenames(args: argparse.Namespace) -> Collection[str]:
 
 def _get_diff() -> bytes:
     _, out, _ = cmd_output_b(
-        'git', 'diff', '--no-ext-diff', '--ignore-submodules', check=False,
+        'git', 'diff', '--no-ext-diff', '--no-textconv', '--ignore-submodules',
+        check=False,
     )
     return out
 
@@ -296,7 +298,8 @@ def _run_hooks(
             verbose=args.verbose, use_color=args.color,
         )
         retval |= current_retval
-        if retval and (config['fail_fast'] or hook.fail_fast):
+        fail_fast = (config['fail_fast'] or hook.fail_fast or args.fail_fast)
+        if current_retval and fail_fast:
             break
     if retval and args.show_diff_on_failure and prior_diff:
         if args.all_files:
@@ -326,8 +329,7 @@ def _has_unmerged_paths() -> bool:
 
 def _has_unstaged_config(config_file: str) -> bool:
     retcode, _, _ = cmd_output_b(
-        'git', 'diff', '--no-ext-diff', '--exit-code', config_file,
+        'git', 'diff', '--quiet', '--no-ext-diff', config_file, check=False,
-        check=False,
     )
     # be explicit, other git errors don't mean it has an unstaged config.
     return retcode == 1
@@ -389,6 +391,10 @@ def run(
         environ['PRE_COMMIT_FROM_REF'] = args.from_ref
         environ['PRE_COMMIT_TO_REF'] = args.to_ref
 
+    if args.pre_rebase_upstream and args.pre_rebase_branch:
+        environ['PRE_COMMIT_PRE_REBASE_UPSTREAM'] = args.pre_rebase_upstream
+        environ['PRE_COMMIT_PRE_REBASE_BRANCH'] = args.pre_rebase_branch
+
     if (
         args.remote_name and args.remote_url and
         args.remote_branch and args.local_branch

pre_commit/commands/validate_config.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 from pre_commit import clientlib
 

pre_commit/commands/validate_manifest.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 from pre_commit import clientlib
 

pre_commit/constants.py

@@ -10,17 +10,4 @@ LOCAL_REPO_VERSION = '1'
 
 VERSION = importlib.metadata.version('pre_commit')
 
-# `manual` is not invoked by any installed git hook.  See #719
-STAGES = (
-    'commit', 'merge-commit', 'prepare-commit-msg', 'commit-msg',
-    'post-commit', 'manual', 'post-checkout', 'push', 'post-merge',
-    'post-rewrite',
-)
-
-HOOK_TYPES = (
-    'pre-commit', 'pre-merge-commit', 'pre-push', 'prepare-commit-msg',
-    'commit-msg', 'post-commit', 'post-checkout', 'post-merge',
-    'post-rewrite',
-)
-
 DEFAULT = 'default'

pre_commit/envcontext.py

@@ -3,10 +3,9 @@ from __future__ import annotations
 import contextlib
 import enum
 import os
-from typing import Generator
+from collections.abc import Generator
-from typing import MutableMapping
+from collections.abc import MutableMapping
 from typing import NamedTuple
-from typing import Tuple
 from typing import Union
 
 _Unset = enum.Enum('_Unset', 'UNSET')
@@ -18,9 +17,9 @@ class Var(NamedTuple):
     default: str = ''
 
 
-SubstitutionT = Tuple[Union[str, Var], ...]
+SubstitutionT = tuple[Union[str, Var], ...]
 ValueT = Union[str, _Unset, SubstitutionT]
-PatchesT = Tuple[Tuple[str, ValueT], ...]
+PatchesT = tuple[tuple[str, ValueT], ...]
 
 
 def format_env(parts: SubstitutionT, env: MutableMapping[str, str]) -> str:
@@ -34,7 +33,7 @@ def format_env(parts: SubstitutionT, env: MutableMapping[str, str]) -> str:
 def envcontext(
         patch: PatchesT,
         _env: MutableMapping[str, str] | None = None,
-) -> Generator[None, None, None]:
+) -> Generator[None]:
     """In this context, `os.environ` is modified according to `patch`.
 
     `patch` is an iterable of 2-tuples (key, value):

pre_commit/error_handler.py

@@ -5,7 +5,7 @@ import functools
 import os.path
 import sys
 import traceback
-from typing import Generator
+from collections.abc import Generator
 from typing import IO
 
 import pre_commit.constants as C
@@ -68,7 +68,7 @@ def _log_and_exit(
 
 
 @contextlib.contextmanager
-def error_handler() -> Generator[None, None, None]:
+def error_handler() -> Generator[None]:
     try:
         yield
     except (Exception, KeyboardInterrupt) as e:

pre_commit/file_lock.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import contextlib
 import errno
 import sys
-from typing import Callable
+from collections.abc import Callable
-from typing import Generator
+from collections.abc import Generator
 
 
 if sys.platform == 'win32':  # pragma: no cover (windows)
@@ -20,7 +20,7 @@ if sys.platform == 'win32':  # pragma: no cover (windows)
     def _locked(
             fileno: int,
             blocked_cb: Callable[[], None],
-    ) -> Generator[None, None, None]:
+    ) -> Generator[None]:
         try:
             msvcrt.locking(fileno, msvcrt.LK_NBLCK, _region)
         except OSError:
@@ -53,7 +53,7 @@ else:  # pragma: win32 no cover
     def _locked(
             fileno: int,
             blocked_cb: Callable[[], None],
-    ) -> Generator[None, None, None]:
+    ) -> Generator[None]:
         try:
             fcntl.flock(fileno, fcntl.LOCK_EX | fcntl.LOCK_NB)
         except OSError:  # pragma: no cover (tests are single-threaded)
@@ -69,7 +69,7 @@ else:  # pragma: win32 no cover
 def lock(
         path: str,
         blocked_cb: Callable[[], None],
-) -> Generator[None, None, None]:
+) -> Generator[None]:
     with open(path, 'a+') as f:
         with _locked(f.fileno(), blocked_cb):
             yield

pre_commit/git.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import os.path
 import sys
-from typing import Mapping
+from collections.abc import Mapping
 
 from pre_commit.errors import FatalError
 from pre_commit.util import CalledProcessError
@@ -126,7 +126,7 @@ def get_conflicted_files() -> set[str]:
     merge_diff_filenames = zsplit(
         cmd_output(
             'git', 'diff', '--name-only', '--no-ext-diff', '-z',
-            '-m', tree_hash, 'HEAD', 'MERGE_HEAD',
+            '-m', tree_hash, 'HEAD', 'MERGE_HEAD', '--',
         )[1],
     )
     return set(merge_conflict_filenames) | set(merge_diff_filenames)
@@ -219,7 +219,7 @@ def check_for_cygwin_mismatch() -> None:
 
         if is_cygwin_python ^ is_cygwin_git:
             exe_type = {True: '(cygwin)', False: '(windows)'}
-            logger.warn(
+            logger.warning(
                 f'pre-commit has detected a mix of cygwin python / git\n'
                 f'This combination is not supported, it is likely you will '
                 f'receive an error later in the program.\n'

pre_commit/hook.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Sequence
 from typing import Any
 from typing import NamedTuple
-from typing import Sequence
 
 from pre_commit.prefix import Prefix
 

pre_commit/lang_base.py

@@ -1,27 +1,65 @@
 from __future__ import annotations
 
 import contextlib
-import multiprocessing
 import os
 import random
 import re
 import shlex
+import sys
+from collections.abc import Generator
+from collections.abc import Sequence
 from typing import Any
-from typing import Generator
+from typing import ContextManager
 from typing import NoReturn
-from typing import Sequence
+from typing import Protocol
 
 import pre_commit.constants as C
 from pre_commit import parse_shebang
+from pre_commit import xargs
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output_b
-from pre_commit.xargs import xargs
 
 FIXED_RANDOM_SEED = 1542676187
 
 SHIMS_RE = re.compile(r'[/\\]shims[/\\]')
 
 
+class Language(Protocol):
+    # Use `None` for no installation / environment
+    @property
+    def ENVIRONMENT_DIR(self) -> str | None: ...
+    # return a value to replace `'default` for `language_version`
+    def get_default_version(self) -> str: ...
+    # return whether the environment is healthy (or should be rebuilt)
+    def health_check(self, prefix: Prefix, version: str) -> str | None: ...
+
+    # install a repository for the given language and language_version
+    def install_environment(
+            self,
+            prefix: Prefix,
+            version: str,
+            additional_dependencies: Sequence[str],
+    ) -> None:
+        ...
+
+    # modify the environment for hook execution
+    def in_env(self, prefix: Prefix, version: str) -> ContextManager[None]: ...
+
+    # execute a hook and return the exit code and output
+    def run_hook(
+            self,
+            prefix: Prefix,
+            entry: str,
+            args: Sequence[str],
+            file_args: Sequence[str],
+            *,
+            is_local: bool,
+            require_serial: bool,
+            color: bool,
+    ) -> tuple[int, bytes]:
+        ...
+
+
 def exe_exists(exe: str) -> bool:
     found = parse_shebang.find_executable(exe)
     if found is None:  # exe exists
@@ -45,7 +83,7 @@ def exe_exists(exe: str) -> bool:
     )
 
 
-def run_setup_cmd(prefix: Prefix, cmd: tuple[str, ...], **kwargs: Any) -> None:
+def setup_cmd(prefix: Prefix, cmd: tuple[str, ...], **kwargs: Any) -> None:
     cmd_output_b(*cmd, cwd=prefix.prefix_dir, **kwargs)
 
 
@@ -90,7 +128,7 @@ def no_install(
 
 
 @contextlib.contextmanager
-def no_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def no_env(prefix: Prefix, version: str) -> Generator[None]:
     yield
 
 
@@ -102,10 +140,7 @@ def target_concurrency() -> int:
         if 'TRAVIS' in os.environ:
             return 2
         else:
-            try:
+            return xargs.cpu_count()
-                return multiprocessing.cpu_count()
-            except NotImplementedError:
-                return 1
 
 
 def _shuffled(seq: Sequence[str]) -> list[str]:
@@ -133,11 +168,14 @@ def run_xargs(
         # ordering.
         file_args = _shuffled(file_args)
         jobs = target_concurrency()
-    return xargs(cmd, file_args, target_concurrency=jobs, color=color)
+    return xargs.xargs(cmd, file_args, target_concurrency=jobs, color=color)
 
 
 def hook_cmd(entry: str, args: Sequence[str]) -> tuple[str, ...]:
-    return (*shlex.split(entry), *args)
+    cmd = shlex.split(entry)
+    if cmd[:2] == ['pre-commit', 'hazmat']:
+        cmd = [sys.executable, '-m', 'pre_commit.commands.hazmat', *cmd[2:]]
+    return (*cmd, *args)
 
 
 def basic_run_hook(

pre_commit/languages/all.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-from typing import ContextManager
-from typing import Protocol
-from typing import Sequence
-
-from pre_commit.languages import conda
-from pre_commit.languages import coursier
-from pre_commit.languages import dart
-from pre_commit.languages import docker
-from pre_commit.languages import docker_image
-from pre_commit.languages import dotnet
-from pre_commit.languages import fail
-from pre_commit.languages import golang
-from pre_commit.languages import lua
-from pre_commit.languages import node
-from pre_commit.languages import perl
-from pre_commit.languages import pygrep
-from pre_commit.languages import python
-from pre_commit.languages import r
-from pre_commit.languages import ruby
-from pre_commit.languages import rust
-from pre_commit.languages import script
-from pre_commit.languages import swift
-from pre_commit.languages import system
-from pre_commit.prefix import Prefix
-
-
-class Language(Protocol):
-    # Use `None` for no installation / environment
-    @property
-    def ENVIRONMENT_DIR(self) -> str | None: ...
-    # return a value to replace `'default` for `language_version`
-    def get_default_version(self) -> str: ...
-
-    # return whether the environment is healthy (or should be rebuilt)
-    def health_check(
-            self,
-            prefix: Prefix,
-            language_version: str,
-    ) -> str | None:
-        ...
-
-    # install a repository for the given language and language_version
-    def install_environment(
-            self,
-            prefix: Prefix,
-            version: str,
-            additional_dependencies: Sequence[str],
-    ) -> None:
-        ...
-
-    # modify the environment for hook execution
-    def in_env(
-            self,
-            prefix: Prefix,
-            version: str,
-    ) -> ContextManager[None]:
-        ...
-
-    # execute a hook and return the exit code and output
-    def run_hook(
-            self,
-            prefix: Prefix,
-            entry: str,
-            args: Sequence[str],
-            file_args: Sequence[str],
-            *,
-            is_local: bool,
-            require_serial: bool,
-            color: bool,
-    ) -> tuple[int, bytes]:
-        ...
-
-
-languages: dict[str, Language] = {
-    'conda': conda,
-    'coursier': coursier,
-    'dart': dart,
-    'docker': docker,
-    'docker_image': docker_image,
-    'dotnet': dotnet,
-    'fail': fail,
-    'golang': golang,
-    'lua': lua,
-    'node': node,
-    'perl': perl,
-    'pygrep': pygrep,
-    'python': python,
-    'r': r,
-    'ruby': ruby,
-    'rust': rust,
-    'script': script,
-    'swift': swift,
-    'system': system,
-    # TODO: fully deprecate `python_venv`
-    'python_venv': python,
-}
-all_languages = sorted(languages)

pre_commit/languages/conda.py

@@ -2,22 +2,23 @@ from __future__ import annotations
 
 import contextlib
 import os
-from typing import Generator
+import sys
-from typing import Sequence
+from collections.abc import Generator
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import SubstitutionT
 from pre_commit.envcontext import UNSET
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output_b
 
 ENVIRONMENT_DIR = 'conda'
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def get_env_patch(env: str) -> PatchesT:
@@ -26,7 +27,7 @@ def get_env_patch(env: str) -> PatchesT:
     # $CONDA_PREFIX/Scripts and $CONDA_PREFIX. Whereas the latter only
     # seems to be used for python.exe.
     path: SubstitutionT = (os.path.join(env, 'bin'), os.pathsep, Var('PATH'))
-    if os.name == 'nt':  # pragma: no cover (platform specific)
+    if sys.platform == 'win32':  # pragma: win32 cover
         path = (env, os.pathsep, *path)
         path = (os.path.join(env, 'Scripts'), os.pathsep, *path)
         path = (os.path.join(env, 'Library', 'bin'), os.pathsep, *path)
@@ -40,8 +41,8 @@ def get_env_patch(env: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -60,11 +61,11 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    helpers.assert_version_default('conda', version)
+    lang_base.assert_version_default('conda', version)
 
     conda_exe = _conda_exe()
 
-    env_dir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    env_dir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     cmd_output_b(
         conda_exe, 'env', 'create', '-p', env_dir, '--file',
         'environment.yml', cwd=prefix.prefix_dir,

pre_commit/languages/coursier.py

@@ -2,22 +2,22 @@ from __future__ import annotations
 
 import contextlib
 import os.path
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
 from pre_commit.errors import FatalError
-from pre_commit.languages import helpers
 from pre_commit.parse_shebang import find_executable
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = 'coursier'
 
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def install_environment(
@@ -25,7 +25,7 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    helpers.assert_version_default('coursier', version)
+    lang_base.assert_version_default('coursier', version)
 
     # Support both possible executable names (either "cs" or "coursier")
     cs = find_executable('cs') or find_executable('coursier')
@@ -35,12 +35,12 @@ def install_environment(
             'executables in the application search path',
         )
 
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     def _install(*opts: str) -> None:
         assert cs is not None
-        helpers.run_setup_cmd(prefix, (cs, 'fetch', *opts))
+        lang_base.setup_cmd(prefix, (cs, 'fetch', *opts))
-        helpers.run_setup_cmd(prefix, (cs, 'install', '--dir', envdir, *opts))
+        lang_base.setup_cmd(prefix, (cs, 'install', '--dir', envdir, *opts))
 
     with in_env(prefix, version):
         channel = prefix.path('.pre-commit-channel')
@@ -70,7 +70,7 @@ def get_env_patch(target_dir: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield

pre_commit/languages/dart.py

@@ -4,22 +4,22 @@ import contextlib
 import os.path
 import shutil
 import tempfile
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import win_exe
 from pre_commit.yaml import yaml_load
 
 ENVIRONMENT_DIR = 'dartenv'
 
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def get_env_patch(venv: str) -> PatchesT:
@@ -29,8 +29,8 @@ def get_env_patch(venv: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -40,9 +40,9 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    helpers.assert_version_default('dart', version)
+    lang_base.assert_version_default('dart', version)
 
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     bin_dir = os.path.join(envdir, 'bin')
 
     def _install_dir(prefix_p: Prefix, pub_cache: str) -> None:
@@ -51,10 +51,10 @@ def install_environment(
         with open(prefix_p.path('pubspec.yaml')) as f:
             pubspec_contents = yaml_load(f)
 
-        helpers.run_setup_cmd(prefix_p, ('dart', 'pub', 'get'), env=dart_env)
+        lang_base.setup_cmd(prefix_p, ('dart', 'pub', 'get'), env=dart_env)
 
         for executable in pubspec_contents['executables']:
-            helpers.run_setup_cmd(
+            lang_base.setup_cmd(
                 prefix_p,
                 (
                     'dart', 'compile', 'exe',
@@ -77,7 +77,7 @@ def install_environment(
             else:
                 dep_cmd = (dep,)
 
-            helpers.run_setup_cmd(
+            lang_base.setup_cmd(
                 prefix,
                 ('dart', 'pub', 'cache', 'add', *dep_cmd),
                 env={**os.environ, 'PUB_CACHE': dep_tmp},

pre_commit/languages/docker.py

@@ -1,46 +1,51 @@
 from __future__ import annotations
 
+import contextlib
+import functools
 import hashlib
 import json
 import os
-from typing import Sequence
+import re
+from collections.abc import Sequence
 
-from pre_commit.languages import helpers
+from pre_commit import lang_base
 from pre_commit.prefix import Prefix
 from pre_commit.util import CalledProcessError
 from pre_commit.util import cmd_output_b
 
 ENVIRONMENT_DIR = 'docker'
 PRE_COMMIT_LABEL = 'PRE_COMMIT'
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-in_env = helpers.no_env  # no special environment for docker
+in_env = lang_base.no_env  # no special environment for docker
+
+_HOSTNAME_MOUNT_RE = re.compile(
+    rb"""
+    /containers
+    (?:/overlay-containers)?
+    /([a-z0-9]{64})
+    (?:/userdata)?
+    /hostname
+    """,
+    re.VERBOSE,
+)
 
 
-def _is_in_docker() -> bool:
+def _get_container_id() -> str | None:
-    try:
+    with contextlib.suppress(FileNotFoundError):
-        with open('/proc/1/cgroup', 'rb') as f:
+        with open('/proc/1/mountinfo', 'rb') as f:
-            return b'docker' in f.read()
+            for line in f:
-    except FileNotFoundError:
+                m = _HOSTNAME_MOUNT_RE.search(line)
-        return False
+                if m:
+                    return m[1].decode()
 
-
+    return None
-def _get_container_id() -> str:
-    # It's assumed that we already check /proc/1/cgroup in _is_in_docker. The
-    # cpuset cgroup controller existed since cgroups were introduced so this
-    # way of getting the container ID is pretty reliable.
-    with open('/proc/1/cgroup', 'rb') as f:
-        for line in f.readlines():
-            if line.split(b':')[1] == b'cpuset':
-                return os.path.basename(line.split(b':')[2]).strip().decode()
-    raise RuntimeError('Failed to find the container ID in /proc/1/cgroup.')
 
 
 def _get_docker_path(path: str) -> str:
-    if not _is_in_docker():
-        return path
-
     container_id = _get_container_id()
+    if container_id is None:
+        return path
 
     try:
         _, out, _ = cmd_output_b('docker', 'inspect', container_id)
@@ -84,16 +89,16 @@ def build_docker_image(
         cmd += ('--pull',)
     # This must come last for old versions of docker.  See #477
     cmd += ('.',)
-    helpers.run_setup_cmd(prefix, cmd)
+    lang_base.setup_cmd(prefix, cmd)
 
 
 def install_environment(
         prefix: Prefix, version: str, additional_dependencies: Sequence[str],
 ) -> None:  # pragma: win32 no cover
-    helpers.assert_version_default('docker', version)
+    lang_base.assert_version_default('docker', version)
-    helpers.assert_no_additional_deps('docker', additional_dependencies)
+    lang_base.assert_no_additional_deps('docker', additional_dependencies)
 
-    directory = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    directory = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     # Docker doesn't really have relevant disk environment, but pre-commit
     # still needs to cleanup its state files on failure
@@ -101,17 +106,47 @@ def install_environment(
     os.mkdir(directory)
 
 
+@functools.lru_cache(maxsize=1)
+def _is_rootless() -> bool:  # pragma: win32 no cover
+    retcode, out, _ = cmd_output_b(
+        'docker', 'system', 'info', '--format', '{{ json . }}',
+    )
+    if retcode != 0:
+        return False
+
+    info = json.loads(out)
+    try:
+        return (
+            # docker:
+            # https://docs.docker.com/reference/api/engine/version/v1.48/#tag/System/operation/SystemInfo
+            'name=rootless' in (info.get('SecurityOptions') or ()) or
+            # podman:
+            # https://docs.podman.io/en/latest/_static/api.html?version=v5.4#tag/system/operation/SystemInfoLibpod
+            info['host']['security']['rootless']
+        )
+    except KeyError:
+        return False
+
+
 def get_docker_user() -> tuple[str, ...]:  # pragma: win32 no cover
+    if _is_rootless():
+        return ()
+
     try:
         return ('-u', f'{os.getuid()}:{os.getgid()}')
     except AttributeError:
         return ()
 
 
-def docker_cmd() -> tuple[str, ...]:  # pragma: win32 no cover
+def get_docker_tty(*, color: bool) -> tuple[str, ...]:  # pragma: win32 no cover  # noqa: E501
+    return (('--tty',) if color else ())
+
+
+def docker_cmd(*, color: bool) -> tuple[str, ...]:  # pragma: win32 no cover
     return (
         'docker', 'run',
         '--rm',
+        *get_docker_tty(color=color),
         *get_docker_user(),
         # https://docs.docker.com/engine/reference/commandline/run/#mount-volumes-from-container-volumes-from
         # The `Z` option tells Docker to label the content with a private
@@ -135,12 +170,11 @@ def run_hook(
     # automated cleanup of docker images.
     build_docker_image(prefix, pull=False)
 
-    entry_exe, *cmd_rest = helpers.hook_cmd(entry, args)
+    entry_exe, *cmd_rest = lang_base.hook_cmd(entry, args)
 
     entry_tag = ('--entrypoint', entry_exe, docker_tag(prefix))
-    cmd = (*docker_cmd(), *entry_tag, *cmd_rest)
+    return lang_base.run_xargs(
-    return helpers.run_xargs(
+        (*docker_cmd(color=color), *entry_tag, *cmd_rest),
-        cmd,
         file_args,
         require_serial=require_serial,
         color=color,

pre_commit/languages/docker_image.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
-from pre_commit.languages import helpers
+from pre_commit import lang_base
 from pre_commit.languages.docker import docker_cmd
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = None
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-install_environment = helpers.no_install
+install_environment = lang_base.no_install
-in_env = helpers.no_env
+in_env = lang_base.no_env
 
 
 def run_hook(
@@ -23,8 +23,8 @@ def run_hook(
         require_serial: bool,
         color: bool,
 ) -> tuple[int, bytes]:  # pragma: win32 no cover
-    cmd = docker_cmd() + helpers.hook_cmd(entry, args)
+    cmd = docker_cmd(color=color) + lang_base.hook_cmd(entry, args)
-    return helpers.run_xargs(
+    return lang_base.run_xargs(
         cmd,
         file_args,
         require_serial=require_serial,

pre_commit/languages/dotnet.py

@@ -6,21 +6,21 @@ import re
 import tempfile
 import xml.etree.ElementTree
 import zipfile
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = 'dotnetenv'
 BIN_DIR = 'bin'
 
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def get_env_patch(venv: str) -> PatchesT:
@@ -30,14 +30,14 @@ def get_env_patch(venv: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
 
 @contextlib.contextmanager
-def _nuget_config_no_sources() -> Generator[str, None, None]:
+def _nuget_config_no_sources() -> Generator[str]:
     with tempfile.TemporaryDirectory() as tmpdir:
         nuget_config = os.path.join(tmpdir, 'nuget.config')
         with open(nuget_config, 'w') as f:
@@ -57,19 +57,19 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    helpers.assert_version_default('dotnet', version)
+    lang_base.assert_version_default('dotnet', version)
-    helpers.assert_no_additional_deps('dotnet', additional_dependencies)
+    lang_base.assert_no_additional_deps('dotnet', additional_dependencies)
 
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
-    build_dir = 'pre-commit-build'
+    build_dir = prefix.path('pre-commit-build')
 
     # Build & pack nupkg file
-    helpers.run_setup_cmd(
+    lang_base.setup_cmd(
         prefix,
         (
             'dotnet', 'pack',
             '--configuration', 'Release',
-            '--output', build_dir,
+            '--property', f'PackageOutputPath={build_dir}',
         ),
     )
 
@@ -99,7 +99,7 @@ def install_environment(
 
         # Install to bin dir
         with _nuget_config_no_sources() as nuget_config:
-            helpers.run_setup_cmd(
+            lang_base.setup_cmd(
                 prefix,
                 (
                     'dotnet', 'tool', 'install',
@@ -109,7 +109,3 @@ def install_environment(
                     tool_id,
                 ),
             )
-
-    # Clean the git dir, ignoring the environment dir
-    clean_cmd = ('git', 'clean', '-ffxd', '-e', f'{ENVIRONMENT_DIR}-*')
-    helpers.run_setup_cmd(prefix, clean_cmd)

pre_commit/languages/fail.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
-from pre_commit.languages import helpers
+from pre_commit import lang_base
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = None
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-install_environment = helpers.no_install
+install_environment = lang_base.no_install
-in_env = helpers.no_env
+in_env = lang_base.no_env
 
 
 def run_hook(

pre_commit/languages/golang.py

@@ -12,24 +12,25 @@ import tempfile
 import urllib.error
 import urllib.request
 import zipfile
+from collections.abc import Generator
+from collections.abc import Sequence
 from typing import ContextManager
-from typing import Generator
 from typing import IO
 from typing import Protocol
-from typing import Sequence
 
 import pre_commit.constants as C
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
+from pre_commit.git import no_git_env
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output
 from pre_commit.util import rmtree
 
 ENVIRONMENT_DIR = 'golangenv'
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 _ARCH_ALIASES = {
     'x86_64': 'amd64',
@@ -60,7 +61,7 @@ else:  # pragma: win32 no cover
 
 @functools.lru_cache(maxsize=1)
 def get_default_version() -> str:
-    if helpers.exe_exists('go'):
+    if lang_base.exe_exists('go'):
         return 'system'
     else:
         return C.DEFAULT
@@ -74,6 +75,7 @@ def get_env_patch(venv: str, version: str) -> PatchesT:
 
     return (
         ('GOROOT', os.path.join(venv, '.go')),
+        ('GOTOOLCHAIN', 'local'),
         (
             'PATH', (
                 os.path.join(venv, 'bin'), os.pathsep,
@@ -88,8 +90,7 @@ def _infer_go_version(version: str) -> str:
     if version != C.DEFAULT:
         return version
     resp = urllib.request.urlopen('https://go.dev/dl/?mode=json')
-    # TODO: 3.9+ .removeprefix('go')
+    return json.load(resp)[0]['version'].removeprefix('go')
-    return json.load(resp)[0]['version'][2:]
 
 
 def _get_url(version: str) -> str:
@@ -120,8 +121,8 @@ def _install_go(version: str, dest: str) -> None:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir, version)):
         yield
 
@@ -131,7 +132,7 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    env_dir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    env_dir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     if version != 'system':
         _install_go(version, env_dir)
@@ -141,17 +142,18 @@ def install_environment(
     else:
         gopath = env_dir
 
-    env = dict(os.environ, GOPATH=gopath)
+    env = no_git_env(dict(os.environ, GOPATH=gopath))
     env.pop('GOBIN', None)
     if version != 'system':
+        env['GOTOOLCHAIN'] = 'local'
         env['GOROOT'] = os.path.join(env_dir, '.go')
         env['PATH'] = os.pathsep.join((
             os.path.join(env_dir, '.go', 'bin'), os.environ['PATH'],
         ))
 
-    helpers.run_setup_cmd(prefix, ('go', 'install', './...'), env=env)
+    lang_base.setup_cmd(prefix, ('go', 'install', './...'), env=env)
     for dependency in additional_dependencies:
-        helpers.run_setup_cmd(prefix, ('go', 'install', dependency), env=env)
+        lang_base.setup_cmd(prefix, ('go', 'install', dependency), env=env)
 
     # save some disk space -- we don't need this after installation
     pkgdir = os.path.join(env_dir, 'pkg')

pre_commit/languages/haskell.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import contextlib
+import os.path
+from collections.abc import Generator
+from collections.abc import Sequence
+
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import Var
+from pre_commit.errors import FatalError
+from pre_commit.prefix import Prefix
+
+ENVIRONMENT_DIR = 'hs_env'
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+run_hook = lang_base.basic_run_hook
+
+
+def get_env_patch(target_dir: str) -> PatchesT:
+    bin_path = os.path.join(target_dir, 'bin')
+    return (('PATH', (bin_path, os.pathsep, Var('PATH'))),)
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir)):
+        yield
+
+
+def install_environment(
+    prefix: Prefix,
+    version: str,
+    additional_dependencies: Sequence[str],
+) -> None:
+    lang_base.assert_version_default('haskell', version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    pkgs = [*prefix.star('.cabal'), *additional_dependencies]
+    if not pkgs:
+        raise FatalError('Expected .cabal files or additional_dependencies')
+
+    bindir = os.path.join(envdir, 'bin')
+    os.makedirs(bindir, exist_ok=True)
+    lang_base.setup_cmd(prefix, ('cabal', 'update'))
+    lang_base.setup_cmd(
+        prefix,
+        (
+            'cabal', 'install',
+            '--install-method', 'copy',
+            '--installdir', bindir,
+            *pkgs,
+        ),
+    )

pre_commit/languages/julia.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+from collections.abc import Generator
+from collections.abc import Sequence
+
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import UNSET
+from pre_commit.prefix import Prefix
+from pre_commit.util import cmd_output_b
+
+ENVIRONMENT_DIR = 'juliaenv'
+health_check = lang_base.basic_health_check
+get_default_version = lang_base.basic_get_default_version
+
+
+def run_hook(
+        prefix: Prefix,
+        entry: str,
+        args: Sequence[str],
+        file_args: Sequence[str],
+        *,
+        is_local: bool,
+        require_serial: bool,
+        color: bool,
+) -> tuple[int, bytes]:
+    # `entry` is a (hook-repo relative) file followed by (optional) args, e.g.
+    # `bin/id.jl` or `bin/hook.jl --arg1 --arg2` so we
+    # 1) shell parse it and join with args with hook_cmd
+    # 2) prepend the hooks prefix path to the first argument (the file), unless
+    #    it is a local script
+    # 3) prepend `julia` as the interpreter
+
+    cmd = lang_base.hook_cmd(entry, args)
+    script = cmd[0] if is_local else prefix.path(cmd[0])
+    cmd = ('julia', '--startup-file=no', script, *cmd[1:])
+    return lang_base.run_xargs(
+        cmd,
+        file_args,
+        require_serial=require_serial,
+        color=color,
+    )
+
+
+def get_env_patch(target_dir: str, version: str) -> PatchesT:
+    return (
+        ('JULIA_LOAD_PATH', target_dir),
+        # May be set, remove it to not interfer with LOAD_PATH
+        ('JULIA_PROJECT', UNSET),
+    )
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir, version)):
+        yield
+
+
+def install_environment(
+        prefix: Prefix,
+        version: str,
+        additional_dependencies: Sequence[str],
+) -> None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with in_env(prefix, version):
+        # TODO: Support language_version with juliaup similar to rust via
+        # rustup
+        # if version != 'system':
+        #     ...
+
+        # Copy Project.toml to hook env if it exist
+        os.makedirs(envdir, exist_ok=True)
+        project_names = ('JuliaProject.toml', 'Project.toml')
+        project_found = False
+        for project_name in project_names:
+            project_file = prefix.path(project_name)
+            if not os.path.isfile(project_file):
+                continue
+            shutil.copy(project_file, envdir)
+            project_found = True
+            break
+
+        # If no project file was found we create an empty one so that the
+        # package manager doesn't error
+        if not project_found:
+            open(os.path.join(envdir, 'Project.toml'), 'a').close()
+
+        # Copy Manifest.toml to hook env if it exists
+        manifest_names = ('JuliaManifest.toml', 'Manifest.toml')
+        for manifest_name in manifest_names:
+            manifest_file = prefix.path(manifest_name)
+            if not os.path.isfile(manifest_file):
+                continue
+            shutil.copy(manifest_file, envdir)
+            break
+
+        # Julia code to instantiate the hook environment
+        julia_code = """
+        @assert length(ARGS) > 0
+        hook_env = ARGS[1]
+        deps = join(ARGS[2:end], " ")
+
+        # We prepend @stdlib here so that we can load the package manager even
+        # though `get_env_patch` limits `JULIA_LOAD_PATH` to just the hook env.
+        pushfirst!(LOAD_PATH, "@stdlib")
+        using Pkg
+        popfirst!(LOAD_PATH)
+
+        # Instantiate the environment shipped with the hook repo. If we have
+        # additional dependencies we disable precompilation in this step to
+        # avoid double work.
+        precompile = isempty(deps) ? "1" : "0"
+        withenv("JULIA_PKG_PRECOMPILE_AUTO" => precompile) do
+            Pkg.instantiate()
+        end
+
+        # Add additional dependencies (with precompilation)
+        if !isempty(deps)
+            withenv("JULIA_PKG_PRECOMPILE_AUTO" => "1") do
+                Pkg.REPLMode.pkgstr("add " * deps)
+            end
+        end
+        """
+        cmd_output_b(
+            'julia', '--startup-file=no', '-e', julia_code, '--', envdir,
+            *additional_dependencies,
+            cwd=prefix.prefix_dir,
+        )

pre_commit/languages/lua.py

@@ -3,20 +3,20 @@ from __future__ import annotations
 import contextlib
 import os
 import sys
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output
 
 ENVIRONMENT_DIR = 'lua_env'
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def _get_lua_version() -> str:  # pragma: win32 no cover
@@ -44,8 +44,8 @@ def get_env_patch(d: str) -> PatchesT:  # pragma: win32 no cover
 
 
 @contextlib.contextmanager  # pragma: win32 no cover
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -55,9 +55,9 @@ def install_environment(
     version: str,
     additional_dependencies: Sequence[str],
 ) -> None:  # pragma: win32 no cover
-    helpers.assert_version_default('lua', version)
+    lang_base.assert_version_default('lua', version)
 
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with in_env(prefix, version):
         # luarocks doesn't bootstrap a tree prior to installing
         # so ensure the directory exists.
@@ -66,10 +66,10 @@ def install_environment(
         # Older luarocks (e.g., 2.4.2) expect the rockspec as an arg
         for rockspec in prefix.star('.rockspec'):
             make_cmd = ('luarocks', '--tree', envdir, 'make', rockspec)
-            helpers.run_setup_cmd(prefix, make_cmd)
+            lang_base.setup_cmd(prefix, make_cmd)
 
         # luarocks can't install multiple packages at once
         # so install them individually.
         for dependency in additional_dependencies:
             cmd = ('luarocks', '--tree', envdir, 'install', dependency)
-            helpers.run_setup_cmd(prefix, cmd)
+            lang_base.setup_cmd(prefix, cmd)

pre_commit/languages/node.py

@@ -4,15 +4,15 @@ import contextlib
 import functools
 import os
 import sys
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import UNSET
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.languages.python import bin_dir
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output
@@ -20,7 +20,7 @@ from pre_commit.util import cmd_output_b
 from pre_commit.util import rmtree
 
 ENVIRONMENT_DIR = 'node_env'
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 @functools.lru_cache(maxsize=1)
@@ -30,7 +30,7 @@ def get_default_version() -> str:
         return C.DEFAULT
     # if node is already installed, we can save a bunch of setup time by
     # using the installed version
-    elif all(helpers.exe_exists(exe) for exe in ('node', 'npm')):
+    elif all(lang_base.exe_exists(exe) for exe in ('node', 'npm')):
         return 'system'
     else:
         return C.DEFAULT
@@ -59,14 +59,14 @@ def get_env_patch(venv: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
 
-def health_check(prefix: Prefix, language_version: str) -> str | None:
+def health_check(prefix: Prefix, version: str) -> str | None:
-    with in_env(prefix, language_version):
+    with in_env(prefix, version):
         retcode, _, _ = cmd_output_b('node', '--version', check=False)
         if retcode != 0:  # pragma: win32 no cover
             return f'`node --version` returned {retcode}'
@@ -78,7 +78,7 @@ def install_environment(
         prefix: Prefix, version: str, additional_dependencies: Sequence[str],
 ) -> None:
     assert prefix.exists('package.json')
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx?f=255&MSPPError=-2147217396#maxpath
     if sys.platform == 'win32':  # pragma: no cover
@@ -93,16 +93,16 @@ def install_environment(
         # install as if we installed from git
 
         local_install_cmd = (
-            'npm', 'install', '--dev', '--prod',
+            'npm', 'install', '--include=dev', '--include=prod',
             '--ignore-prepublish', '--no-progress', '--no-save',
         )
-        helpers.run_setup_cmd(prefix, local_install_cmd)
+        lang_base.setup_cmd(prefix, local_install_cmd)
 
         _, pkg, _ = cmd_output('npm', 'pack', cwd=prefix.prefix_dir)
         pkg = prefix.path(pkg.strip())
 
         install = ('npm', 'install', '-g', pkg, *additional_dependencies)
-        helpers.run_setup_cmd(prefix, install)
+        lang_base.setup_cmd(prefix, install)
 
         # clean these up after installation
         if prefix.exists('node_modules'):  # pragma: win32 no cover

pre_commit/languages/perl.py

@@ -3,19 +3,19 @@ from __future__ import annotations
 import contextlib
 import os
 import shlex
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = 'perl_env'
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def get_env_patch(venv: str) -> PatchesT:
@@ -33,8 +33,8 @@ def get_env_patch(venv: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -42,9 +42,9 @@ def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
 def install_environment(
         prefix: Prefix, version: str, additional_dependencies: Sequence[str],
 ) -> None:
-    helpers.assert_version_default('perl', version)
+    lang_base.assert_version_default('perl', version)
 
     with in_env(prefix, version):
-        helpers.run_setup_cmd(
+        lang_base.setup_cmd(
             prefix, ('cpan', '-T', '.', *additional_dependencies),
         )

pre_commit/languages/pygrep.py

@@ -3,20 +3,20 @@ from __future__ import annotations
 import argparse
 import re
 import sys
+from collections.abc import Sequence
+from re import Pattern
 from typing import NamedTuple
-from typing import Pattern
-from typing import Sequence
 
+from pre_commit import lang_base
 from pre_commit import output
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.xargs import xargs
 
 ENVIRONMENT_DIR = None
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-install_environment = helpers.no_install
+install_environment = lang_base.no_install
-in_env = helpers.no_env
+in_env = lang_base.no_env
 
 
 def _process_filename_by_line(pattern: Pattern[bytes], filename: str) -> int:

pre_commit/languages/python.py

@@ -4,15 +4,15 @@ import contextlib
 import functools
 import os
 import sys
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import UNSET
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.parse_shebang import find_executable
 from pre_commit.prefix import Prefix
 from pre_commit.util import CalledProcessError
@@ -21,10 +21,10 @@ from pre_commit.util import cmd_output_b
 from pre_commit.util import win_exe
 
 ENVIRONMENT_DIR = 'py_env'
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def _version_info(exe: str) -> str:
     prog = 'import sys;print(".".join(str(p) for p in sys.version_info))'
     try:
@@ -48,7 +48,7 @@ def _read_pyvenv_cfg(filename: str) -> dict[str, str]:
 
 def bin_dir(venv: str) -> str:
     """On windows there's a different directory for the virtualenv"""
-    bin_part = 'Scripts' if os.name == 'nt' else 'bin'
+    bin_part = 'Scripts' if sys.platform == 'win32' else 'bin'
     return os.path.join(venv, bin_part)
 
 
@@ -65,7 +65,7 @@ def _find_by_py_launcher(
         version: str,
 ) -> str | None:  # pragma: no cover (windows only)
     if version.startswith('python'):
-        num = version[len('python'):]
+        num = version.removeprefix('python')
         cmd = ('py', f'-{num}', '-c', 'import sys; print(sys.executable)')
         env = dict(os.environ, PYTHONIOENCODING='UTF-8')
         try:
@@ -75,6 +75,13 @@ def _find_by_py_launcher(
     return None
 
 
+def _impl_exe_name() -> str:
+    if sys.implementation.name == 'cpython':  # pragma: cpython cover
+        return 'python'
+    else:  # pragma: cpython no cover
+        return sys.implementation.name  # pypy mostly
+
+
 def _find_by_sys_executable() -> str | None:
     def _norm(path: str) -> str | None:
         _, exe = os.path.split(path.lower())
@@ -100,18 +107,25 @@ def _find_by_sys_executable() -> str | None:
 
 @functools.lru_cache(maxsize=1)
 def get_default_version() -> str:  # pragma: no cover (platform dependent)
-    # First attempt from `sys.executable` (or the realpath)
+    v_major = f'{sys.version_info[0]}'
-    exe = _find_by_sys_executable()
+    v_minor = f'{sys.version_info[0]}.{sys.version_info[1]}'
-    if exe:
-        return exe
 
-    # Next try the `pythonX.X` executable
+    # attempt the likely implementation exe
-    exe = f'python{sys.version_info[0]}.{sys.version_info[1]}'
+    for potential in (v_minor, v_major):
-    if find_executable(exe):
+        exe = f'{_impl_exe_name()}{potential}'
-        return exe
+        if find_executable(exe):
+            return exe
 
-    if _find_by_py_launcher(exe):
+    # next try `sys.executable` (or the realpath)
-        return exe
+    maybe_exe = _find_by_sys_executable()
+    if maybe_exe:
+        return maybe_exe
+
+    # maybe on windows we can find it via py launcher?
+    if sys.platform == 'win32':  # pragma: win32 cover
+        exe = f'python{v_minor}'
+        if _find_by_py_launcher(exe):
+            return exe
 
     # We tried!
     return C.DEFAULT
@@ -124,7 +138,7 @@ def _sys_executable_matches(version: str) -> bool:
         return False
 
     try:
-        info = tuple(int(p) for p in version[len('python'):].split('.'))
+        info = tuple(int(p) for p in version.removeprefix('python').split('.'))
     except ValueError:
         return False
 
@@ -137,7 +151,7 @@ def norm_version(version: str) -> str | None:
     elif _sys_executable_matches(version):  # virtualenv defaults to our exe
         return None
 
-    if os.name == 'nt':  # pragma: no cover (windows)
+    if sys.platform == 'win32':  # pragma: no cover (windows)
         version_exec = _find_by_py_launcher(version)
         if version_exec:
             return version_exec
@@ -152,14 +166,14 @@ def norm_version(version: str) -> str | None:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
 
-def health_check(prefix: Prefix, language_version: str) -> str | None:
+def health_check(prefix: Prefix, version: str) -> str | None:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, language_version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     pyvenv_cfg = os.path.join(envdir, 'pyvenv.cfg')
 
     # created with "old" virtualenv
@@ -202,7 +216,7 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     venv_cmd = [sys.executable, '-mvirtualenv', envdir]
     python = norm_version(version)
     if python is not None:
@@ -211,4 +225,4 @@ def install_environment(
 
     cmd_output_b(*venv_cmd, cwd='/')
     with in_env(prefix, version):
-        helpers.run_setup_cmd(prefix, install_cmd)
+        lang_base.setup_cmd(prefix, install_cmd)

pre_commit/languages/r.py

@@ -4,21 +4,120 @@ import contextlib
 import os
 import shlex
 import shutil
-from typing import Generator
+import tempfile
-from typing import Sequence
+import textwrap
+from collections.abc import Generator
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import UNSET
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
-from pre_commit.util import cmd_output_b
+from pre_commit.util import cmd_output
 from pre_commit.util import win_exe
 
 ENVIRONMENT_DIR = 'renv'
-RSCRIPT_OPTS = ('--no-save', '--no-restore', '--no-site-file', '--no-environ')
+get_default_version = lang_base.basic_get_default_version
-get_default_version = helpers.basic_get_default_version
+
-health_check = helpers.basic_health_check
+_RENV_ACTIVATED_OPTS = (
+    '--no-save', '--no-restore', '--no-site-file', '--no-environ',
+)
+
+
+def _execute_r(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+        cli_opts: Sequence[str],
+) -> str:
+    with in_env(prefix, version), _r_code_in_tempfile(code) as f:
+        _, out, _ = cmd_output(
+            _rscript_exec(), *cli_opts, f, *args, cwd=cwd,
+        )
+    return out.rstrip('\n')
+
+
+def _execute_r_in_renv(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+) -> str:
+    return _execute_r(
+        code=code, prefix=prefix, version=version, args=args, cwd=cwd,
+        cli_opts=_RENV_ACTIVATED_OPTS,
+    )
+
+
+def _execute_vanilla_r(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+) -> str:
+    return _execute_r(
+        code=code, prefix=prefix, version=version, args=args, cwd=cwd,
+        cli_opts=('--vanilla',),
+    )
+
+
+def _read_installed_version(envdir: str, prefix: Prefix, version: str) -> str:
+    return _execute_r_in_renv(
+        'cat(renv::settings$r.version())',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def _read_executable_version(envdir: str, prefix: Prefix, version: str) -> str:
+    return _execute_r_in_renv(
+        'cat(as.character(getRversion()))',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def _write_current_r_version(
+        envdir: str, prefix: Prefix, version: str,
+) -> None:
+    _execute_r_in_renv(
+        'renv::settings$r.version(as.character(getRversion()))',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def health_check(prefix: Prefix, version: str) -> str | None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    r_version_installation = _read_installed_version(
+        envdir=envdir, prefix=prefix, version=version,
+    )
+    r_version_current_executable = _read_executable_version(
+        envdir=envdir, prefix=prefix, version=version,
+    )
+    if r_version_installation in {'NULL', ''}:
+        return (
+            f'Hooks were installed with an unknown R version. R version for '
+            f'hook repo now set to {r_version_current_executable}'
+        )
+    elif r_version_installation != r_version_current_executable:
+        return (
+            f'Hooks were installed for R version {r_version_installation}, '
+            f'but current R executable has version '
+            f'{r_version_current_executable}'
+        )
+
+    return None
+
+
+@contextlib.contextmanager
+def _r_code_in_tempfile(code: str) -> Generator[str]:
+    """
+    To avoid quoting and escaping issues, avoid `Rscript [options] -e {expr}`
+    but use `Rscript [options] path/to/file_with_expr.R`
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        fname = os.path.join(tmpdir, 'script.R')
+        with open(fname, 'w') as f:
+            f.write(_inline_r_setup(textwrap.dedent(code)))
+        yield fname
 
 
 def get_env_patch(venv: str) -> PatchesT:
@@ -29,8 +128,8 @@ def get_env_patch(venv: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -85,7 +184,7 @@ def _cmd_from_hook(
     _entry_validate(cmd)
 
     cmd_part = _prefix_if_file_entry(cmd, prefix, is_local=is_local)
-    return (cmd[0], *RSCRIPT_OPTS, *cmd_part, *args)
+    return (cmd[0], *_RENV_ACTIVATED_OPTS, *cmd_part, *args)
 
 
 def install_environment(
@@ -93,7 +192,9 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    env_dir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    lang_base.assert_version_default('r', version)
+
+    env_dir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     os.makedirs(env_dir, exist_ok=True)
     shutil.copy(prefix.path('renv.lock'), env_dir)
     shutil.copytree(prefix.path('renv'), os.path.join(env_dir, 'renv'))
@@ -126,21 +227,19 @@ def install_environment(
             renv::install(prefix_dir)
         }}
         """
-
+    _execute_vanilla_r(
-    cmd_output_b(
+        r_code_inst_environment,
-        _rscript_exec(), '--vanilla', '-e',
+        prefix=prefix, version=version, cwd=env_dir,
-        _inline_r_setup(r_code_inst_environment),
-        cwd=env_dir,
     )
+
+    _write_current_r_version(envdir=env_dir, prefix=prefix, version=version)
     if additional_dependencies:
         r_code_inst_add = 'renv::install(commandArgs(trailingOnly = TRUE))'
-        with in_env(prefix, version):
+        _execute_r_in_renv(
-            cmd_output_b(
+            code=r_code_inst_add, prefix=prefix, version=version,
-                _rscript_exec(), *RSCRIPT_OPTS, '-e',
+            args=additional_dependencies,
-                _inline_r_setup(r_code_inst_add),
+            cwd=env_dir,
-                *additional_dependencies,
+        )
-                cwd=env_dir,
-            )
 
 
 def _inline_r_setup(code: str) -> str:
@@ -148,11 +247,16 @@ def _inline_r_setup(code: str) -> str:
     Some behaviour of R cannot be configured via env variables, but can
     only be configured via R options once R has started. These are set here.
     """
-    with_option = f"""\
+    with_option = [
-    options(install.packages.compile.from.source = "never", pkgType = "binary")
+        textwrap.dedent("""\
-    {code}
+        options(
-    """
+            install.packages.compile.from.source = "never",
-    return with_option
+            pkgType = "binary"
+        )
+        """),
+        code,
+    ]
+    return '\n'.join(with_option)
 
 
 def run_hook(
@@ -166,7 +270,7 @@ def run_hook(
         color: bool,
 ) -> tuple[int, bytes]:
     cmd = _cmd_from_hook(prefix, entry, args, is_local=is_local)
-    return helpers.run_xargs(
+    return lang_base.run_xargs(
         cmd,
         file_args,
         require_serial=require_serial,

pre_commit/languages/ruby.py

@@ -2,30 +2,36 @@ from __future__ import annotations
 
 import contextlib
 import functools
+import importlib.resources
 import os.path
 import shutil
 import tarfile
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
+from typing import IO
 
 import pre_commit.constants as C
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import UNSET
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import CalledProcessError
-from pre_commit.util import resource_bytesio
 
 ENVIRONMENT_DIR = 'rbenv'
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
+
+
+def _resource_bytesio(filename: str) -> IO[bytes]:
+    files = importlib.resources.files('pre_commit.resources')
+    return files.joinpath(filename).open('rb')
 
 
 @functools.lru_cache(maxsize=1)
 def get_default_version() -> str:
-    if all(helpers.exe_exists(exe) for exe in ('ruby', 'gem')):
+    if all(lang_base.exe_exists(exe) for exe in ('ruby', 'gem')):
         return 'system'
     else:
         return C.DEFAULT
@@ -39,7 +45,6 @@ def get_env_patch(
         ('GEM_HOME', os.path.join(venv, 'gems')),
         ('GEM_PATH', UNSET),
         ('BUNDLE_IGNORE_CONFIG', '1'),
-        ('BUNDLE_GEMFILE', os.devnull),
     )
     if language_version == 'system':
         patches += (
@@ -68,14 +73,14 @@ def get_env_patch(
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir, version)):
         yield
 
 
 def _extract_resource(filename: str, dest: str) -> None:
-    with resource_bytesio(filename) as bio:
+    with _resource_bytesio(filename) as bio:
         with tarfile.open(fileobj=bio) as tf:
             tf.extractall(dest)
 
@@ -84,7 +89,7 @@ def _install_rbenv(
         prefix: Prefix,
         version: str,
 ) -> None:  # pragma: win32 no cover
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     _extract_resource('rbenv.tar.gz', prefix.path('.'))
     shutil.move(prefix.path('rbenv'), envdir)
@@ -101,36 +106,40 @@ def _install_ruby(
         version: str,
 ) -> None:  # pragma: win32 no cover
     try:
-        helpers.run_setup_cmd(prefix, ('rbenv', 'download', version))
+        lang_base.setup_cmd(prefix, ('rbenv', 'download', version))
     except CalledProcessError:  # pragma: no cover (usually find with download)
         # Failed to download from mirror for some reason, build it instead
-        helpers.run_setup_cmd(prefix, ('rbenv', 'install', version))
+        lang_base.setup_cmd(prefix, ('rbenv', 'install', version))
 
 
 def install_environment(
         prefix: Prefix, version: str, additional_dependencies: Sequence[str],
 ) -> None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
     if version != 'system':  # pragma: win32 no cover
         _install_rbenv(prefix, version)
         with in_env(prefix, version):
             # Need to call this before installing so rbenv's directories
             # are set up
-            helpers.run_setup_cmd(prefix, ('rbenv', 'init', '-'))
+            lang_base.setup_cmd(prefix, ('rbenv', 'init', '-'))
             if version != C.DEFAULT:
                 _install_ruby(prefix, version)
             # Need to call this after installing to set up the shims
-            helpers.run_setup_cmd(prefix, ('rbenv', 'rehash'))
+            lang_base.setup_cmd(prefix, ('rbenv', 'rehash'))
 
     with in_env(prefix, version):
-        helpers.run_setup_cmd(
+        lang_base.setup_cmd(
             prefix, ('gem', 'build', *prefix.star('.gemspec')),
         )
-        helpers.run_setup_cmd(
+        lang_base.setup_cmd(
             prefix,
             (
                 'gem', 'install',
                 '--no-document', '--no-format-executable',
                 '--no-user-install',
+                '--install-dir', os.path.join(envdir, 'gems'),
+                '--bindir', os.path.join(envdir, 'gems', 'bin'),
                 *prefix.star('.gem'), *additional_dependencies,
             ),
         )

pre_commit/languages/rust.py

@@ -7,23 +7,23 @@ import shutil
 import sys
 import tempfile
 import urllib.request
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
+from pre_commit import lang_base
 from pre_commit import parse_shebang
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output_b
 from pre_commit.util import make_executable
 from pre_commit.util import win_exe
 
 ENVIRONMENT_DIR = 'rustenv'
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 @functools.lru_cache(maxsize=1)
@@ -34,7 +34,7 @@ def get_default_version() -> str:
     # Just detecting the executable does not suffice, because if rustup is
     # installed but no toolchain is available, then `cargo` exists but
     # cannot be used without installing a toolchain first.
-    if cmd_output_b('cargo', '--version', check=False)[0] == 0:
+    if cmd_output_b('cargo', '--version', check=False, cwd='/')[0] == 0:
         return 'system'
     else:
         return C.DEFAULT
@@ -50,7 +50,6 @@ def _rust_toolchain(language_version: str) -> str:
 
 def get_env_patch(target_dir: str, version: str) -> PatchesT:
     return (
-        ('CARGO_HOME', target_dir),
         ('PATH', (os.path.join(target_dir, 'bin'), os.pathsep, Var('PATH'))),
         # Only set RUSTUP_TOOLCHAIN if we don't want use the system's default
         # toolchain
@@ -62,8 +61,8 @@ def get_env_patch(target_dir: str, version: str) -> PatchesT:
 
 
 @contextlib.contextmanager
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir, version)):
         yield
 
@@ -78,12 +77,12 @@ def _add_dependencies(
         crate = f'{name}@{spec or "*"}'
         crates.append(crate)
 
-    helpers.run_setup_cmd(prefix, ('cargo', 'add', *crates))
+    lang_base.setup_cmd(prefix, ('cargo', 'add', *crates))
 
 
-def install_rust_with_toolchain(toolchain: str) -> None:
+def install_rust_with_toolchain(toolchain: str, envdir: str) -> None:
     with tempfile.TemporaryDirectory() as rustup_dir:
-        with envcontext((('RUSTUP_HOME', rustup_dir),)):
+        with envcontext((('CARGO_HOME', envdir), ('RUSTUP_HOME', rustup_dir))):
             # acquire `rustup` if not present
             if parse_shebang.find_executable('rustup') is None:
                 # We did not detect rustup and need to download it first.
@@ -116,7 +115,7 @@ def install_environment(
         version: str,
         additional_dependencies: Sequence[str],
 ) -> None:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     # There are two cases where we might want to specify more dependencies:
     # as dependencies for the library being built, and as binary packages
@@ -135,16 +134,21 @@ def install_environment(
 
     packages_to_install: set[tuple[str, ...]] = {('--path', '.')}
     for cli_dep in cli_deps:
-        cli_dep = cli_dep[len('cli:'):]
+        cli_dep = cli_dep.removeprefix('cli:')
         package, _, crate_version = cli_dep.partition(':')
         if crate_version != '':
             packages_to_install.add((package, '--version', crate_version))
         else:
             packages_to_install.add((package,))
 
-    with in_env(prefix, version):
+    with contextlib.ExitStack() as ctx:
+        ctx.enter_context(in_env(prefix, version))
+
         if version != 'system':
-            install_rust_with_toolchain(_rust_toolchain(version))
+            install_rust_with_toolchain(_rust_toolchain(version), envdir)
+
+            tmpdir = ctx.enter_context(tempfile.TemporaryDirectory())
+            ctx.enter_context(envcontext((('RUSTUP_HOME', tmpdir),)))
 
         if len(lib_deps) > 0:
             _add_dependencies(prefix, lib_deps)

pre_commit/languages/swift.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import contextlib
 import os
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
+from pre_commit import lang_base
 from pre_commit.envcontext import envcontext
 from pre_commit.envcontext import PatchesT
 from pre_commit.envcontext import Var
-from pre_commit.languages import helpers
 from pre_commit.prefix import Prefix
 from pre_commit.util import cmd_output_b
 
@@ -16,9 +16,9 @@ BUILD_DIR = '.build'
 BUILD_CONFIG = 'release'
 
 ENVIRONMENT_DIR = 'swift_env'
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-run_hook = helpers.basic_run_hook
+run_hook = lang_base.basic_run_hook
 
 
 def get_env_patch(venv: str) -> PatchesT:  # pragma: win32 no cover
@@ -27,8 +27,8 @@ def get_env_patch(venv: str) -> PatchesT:  # pragma: win32 no cover
 
 
 @contextlib.contextmanager  # pragma: win32 no cover
-def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
     with envcontext(get_env_patch(envdir)):
         yield
 
@@ -36,15 +36,15 @@ def in_env(prefix: Prefix, version: str) -> Generator[None, None, None]:
 def install_environment(
         prefix: Prefix, version: str, additional_dependencies: Sequence[str],
 ) -> None:  # pragma: win32 no cover
-    helpers.assert_version_default('swift', version)
+    lang_base.assert_version_default('swift', version)
-    helpers.assert_no_additional_deps('swift', additional_dependencies)
+    lang_base.assert_no_additional_deps('swift', additional_dependencies)
-    envdir = helpers.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
 
     # Build the swift package
     os.mkdir(envdir)
     cmd_output_b(
         'swift', 'build',
-        '-C', prefix.prefix_dir,
+        '--package-path', prefix.prefix_dir,
         '-c', BUILD_CONFIG,
         '--build-path', os.path.join(envdir, BUILD_DIR),
     )

pre_commit/languages/system.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from pre_commit.languages import helpers
-
-ENVIRONMENT_DIR = None
-get_default_version = helpers.basic_get_default_version
-health_check = helpers.basic_health_check
-install_environment = helpers.no_install
-in_env = helpers.no_env
-run_hook = helpers.basic_run_hook

pre_commit/languages/unsupported.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from pre_commit import lang_base
+
+ENVIRONMENT_DIR = None
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+install_environment = lang_base.no_install
+in_env = lang_base.no_env
+run_hook = lang_base.basic_run_hook

pre_commit/languages/unsupported_script.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
-from pre_commit.languages import helpers
+from pre_commit import lang_base
 from pre_commit.prefix import Prefix
 
 ENVIRONMENT_DIR = None
-get_default_version = helpers.basic_get_default_version
+get_default_version = lang_base.basic_get_default_version
-health_check = helpers.basic_health_check
+health_check = lang_base.basic_health_check
-install_environment = helpers.no_install
+install_environment = lang_base.no_install
-in_env = helpers.no_env
+in_env = lang_base.no_env
 
 
 def run_hook(
@@ -22,9 +22,9 @@ def run_hook(
         require_serial: bool,
         color: bool,
 ) -> tuple[int, bytes]:
-    cmd = helpers.hook_cmd(entry, args)
+    cmd = lang_base.hook_cmd(entry, args)
     cmd = (prefix.path(cmd[0]), *cmd[1:])
-    return helpers.run_xargs(
+    return lang_base.run_xargs(
         cmd,
         file_args,
         require_serial=require_serial,

pre_commit/logging_handler.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import logging
-from typing import Generator
+from collections.abc import Generator
 
 from pre_commit import color
 from pre_commit import output
@@ -32,7 +32,7 @@ class LoggingHandler(logging.Handler):
 
 
 @contextlib.contextmanager
-def logging_handler(use_color: bool) -> Generator[None, None, None]:
+def logging_handler(use_color: bool) -> Generator[None]:
     handler = LoggingHandler(use_color)
     logger.addHandler(handler)
     logger.setLevel(logging.INFO)

pre_commit/main.py

@@ -4,11 +4,13 @@ import argparse
 import logging
 import os
 import sys
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
+from pre_commit import clientlib
 from pre_commit import git
 from pre_commit.color import add_color_option
+from pre_commit.commands import hazmat
 from pre_commit.commands.autoupdate import autoupdate
 from pre_commit.commands.clean import clean
 from pre_commit.commands.gc import gc
@@ -36,8 +38,11 @@ logger = logging.getLogger('pre_commit')
 # pyvenv
 os.environ.pop('__PYVENV_LAUNCHER__', None)
 
+# https://github.com/getsentry/snuba/pull/5388
+os.environ.pop('PYTHONEXECUTABLE', None)
+
 COMMANDS_NO_GIT = {
-    'clean', 'gc', 'init-templatedir', 'sample-config',
+    'clean', 'gc', 'hazmat', 'init-templatedir', 'sample-config',
     'validate-config', 'validate-manifest',
 }
 
@@ -52,16 +57,16 @@ def _add_config_option(parser: argparse.ArgumentParser) -> None:
 def _add_hook_type_option(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         '-t', '--hook-type',
-        choices=C.HOOK_TYPES, action='append', dest='hook_types',
+        choices=clientlib.HOOK_TYPES, action='append', dest='hook_types',
     )
 
 
 def _add_run_options(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('hook', nargs='?', help='A single hook-id to run')
-    parser.add_argument('--verbose', '-v', action='store_true', default=False)
+    parser.add_argument('--verbose', '-v', action='store_true')
     mutex_group = parser.add_mutually_exclusive_group(required=False)
     mutex_group.add_argument(
-        '--all-files', '-a', action='store_true', default=False,
+        '--all-files', '-a', action='store_true',
         help='Run on all the files in the repo.',
     )
     mutex_group.add_argument(
@@ -73,7 +78,14 @@ def _add_run_options(parser: argparse.ArgumentParser) -> None:
         help='When hooks fail, run `git diff` directly afterward.',
     )
     parser.add_argument(
-        '--hook-stage', choices=C.STAGES, default='commit',
+        '--fail-fast', action='store_true',
+        help='Stop after the first failing hook.',
+    )
+    parser.add_argument(
+        '--hook-stage',
+        choices=clientlib.STAGES,
+        type=clientlib.transform_stage,
+        default='pre-commit',
         help='The stage during which the hook is fired.  One of %(choices)s',
     )
     parser.add_argument(
@@ -103,6 +115,17 @@ def _add_run_options(parser: argparse.ArgumentParser) -> None:
             'now checked out.'
         ),
     )
+    parser.add_argument(
+        '--pre-rebase-upstream', help=(
+            'The upstream from which the series was forked.'
+        ),
+    )
+    parser.add_argument(
+        '--pre-rebase-branch', help=(
+            'The branch being rebased, and is not set when  '
+            'rebasing the current branch.'
+        ),
+    )
     parser.add_argument(
         '--commit-msg-filename',
         help='Filename to check when running during `commit-msg`',
@@ -211,14 +234,23 @@ def main(argv: Sequence[str] | None = None) -> int:
         help='Store "frozen" hashes in `rev` instead of tag names',
     )
     autoupdate_parser.add_argument(
-        '--repo', dest='repos', action='append', metavar='REPO',
+        '--repo', dest='repos', action='append', metavar='REPO', default=[],
         help='Only update this repository -- may be specified multiple times.',
     )
+    autoupdate_parser.add_argument(
+        '-j', '--jobs', type=int, default=1,
+        help='Number of threads to use.  (default %(default)s).',
+    )
 
     _add_cmd('clean', help='Clean out pre-commit files.')
 
     _add_cmd('gc', help='Clean unused cached repos.')
 
+    hazmat_parser = _add_cmd(
+        'hazmat', help='Composable tools for rare use in hook `entry`.',
+    )
+    hazmat.add_parsers(hazmat_parser)
+
     init_templatedir_parser = _add_cmd(
         'init-templatedir',
         help=(
@@ -253,7 +285,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
     _add_hook_type_option(install_parser)
     install_parser.add_argument(
-        '--allow-missing-config', action='store_true', default=False,
+        '--allow-missing-config', action='store_true',
         help=(
             'Whether to allow a missing `pre-commit` configuration file '
             'or exit with a failure code.'
@@ -353,15 +385,18 @@ def main(argv: Sequence[str] | None = None) -> int:
 
         if args.command == 'autoupdate':
             return autoupdate(
-                args.config, store,
+                args.config,
                 tags_only=not args.bleeding_edge,
                 freeze=args.freeze,
                 repos=args.repos,
+                jobs=args.jobs,
             )
         elif args.command == 'clean':
             return clean(store)
         elif args.command == 'gc':
             return gc(store)
+        elif args.command == 'hazmat':
+            return hazmat.impl(args)
         elif args.command == 'hook-impl':
             return hook_impl(
                 store,

pre_commit/meta_hooks/check_hooks_apply.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import argparse
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
 from pre_commit import git
@@ -21,7 +21,7 @@ def check_all_hooks_match_files(config_file: str) -> int:
     for hook in all_hooks(config, Store()):
         if hook.always_run or hook.language == 'fail':
             continue
-        elif not classifier.filenames_for_hook(hook):
+        elif not any(classifier.filenames_for_hook(hook)):
             print(f'{hook.id} does not apply to this repository')
             retv = 1
 

pre_commit/meta_hooks/check_useless_excludes.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import argparse
 import re
-from typing import Sequence
+from collections.abc import Iterable
+from collections.abc import Sequence
 
 from cfgv import apply_defaults
 
@@ -14,7 +15,7 @@ from pre_commit.commands.run import Classifier
 
 
 def exclude_matches_any(
-        filenames: Sequence[str],
+        filenames: Iterable[str],
         include: str,
         exclude: str,
 ) -> bool:
@@ -50,11 +51,12 @@ def check_useless_excludes(config_file: str) -> int:
             # Not actually a manifest dict, but this more accurately reflects
             # the defaults applied during runtime
             hook = apply_defaults(hook, MANIFEST_HOOK_DICT)
-            names = classifier.filenames
+            names = classifier.by_types(
-            types = hook['types']
+                classifier.filenames,
-            types_or = hook['types_or']
+                hook['types'],
-            exclude_types = hook['exclude_types']
+                hook['types_or'],
-            names = classifier.by_types(names, types, types_or, exclude_types)
+                hook['exclude_types'],
+            )
             include, exclude = hook['files'], hook['exclude']
             if not exclude_matches_any(names, include, exclude):
                 print(

pre_commit/meta_hooks/identity.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Sequence
+from collections.abc import Sequence
 
 from pre_commit import output
 

pre_commit/parse_shebang.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import os.path
-from typing import Mapping
+from collections.abc import Mapping
 from typing import NoReturn
 
 from identify.identify import parse_shebang_from_file

pre_commit/repository.py

@@ -3,17 +3,16 @@ from __future__ import annotations
 import json
 import logging
 import os
+from collections.abc import Sequence
 from typing import Any
-from typing import Sequence
 
 import pre_commit.constants as C
+from pre_commit.all_languages import languages
 from pre_commit.clientlib import load_manifest
 from pre_commit.clientlib import LOCAL
 from pre_commit.clientlib import META
-from pre_commit.clientlib import parse_version
 from pre_commit.hook import Hook
-from pre_commit.languages.all import languages
+from pre_commit.lang_base import environment_dir
-from pre_commit.languages.helpers import environment_dir
 from pre_commit.prefix import Prefix
 from pre_commit.store import Store
 from pre_commit.util import clean_path_on_failure
@@ -32,7 +31,7 @@ def _state_filename_v2(venv: str) -> str:
 
 
 def _state(additional_deps: Sequence[str]) -> object:
-    return {'additional_dependencies': sorted(additional_deps)}
+    return {'additional_dependencies': additional_deps}
 
 
 def _read_state(venv: str) -> object | None:
@@ -115,15 +114,6 @@ def _hook(
     for dct in rest:
         ret.update(dct)
 
-    version = ret['minimum_pre_commit_version']
-    if parse_version(version) > parse_version(C.VERSION):
-        logger.error(
-            f'The hook `{ret["id"]}` requires pre-commit version {version} '
-            f'but version {C.VERSION} is installed.  '
-            f'Perhaps run `pip install --upgrade pre-commit`.',
-        )
-        exit(1)
-
     lang = ret['language']
     if ret['language_version'] == C.DEFAULT:
         ret['language_version'] = root_config['default_language_version'][lang]

pre_commit/resources/empty_template_pubspec.yaml

@@ -1,4 +1,4 @@
 name: pre_commit_empty_pubspec
 environment:
-  sdk: '>=2.10.0'
+  sdk: '>=2.12.0'
 executables: {}

pre_commit/resources/empty_template_setup.py

@@ -1,4 +1,4 @@
 from setuptools import setup
 
 
-setup(name='pre-commit-placeholder-package', version='0.0.0')
+setup(name='pre-commit-placeholder-package', version='0.0.0', py_modules=[])

pre_commit/staged_files_only.py

@@ -4,9 +4,10 @@ import contextlib
 import logging
 import os.path
 import time
-from typing import Generator
+from collections.abc import Generator
 
 from pre_commit import git
+from pre_commit.errors import FatalError
 from pre_commit.util import CalledProcessError
 from pre_commit.util import cmd_output
 from pre_commit.util import cmd_output_b
@@ -32,7 +33,7 @@ def _git_apply(patch: str) -> None:
 
 
 @contextlib.contextmanager
-def _intent_to_add_cleared() -> Generator[None, None, None]:
+def _intent_to_add_cleared() -> Generator[None]:
     intent_to_add = git.intent_to_add_files()
     if intent_to_add:
         logger.warning('Unstaged intent-to-add files detected.')
@@ -47,14 +48,23 @@ def _intent_to_add_cleared() -> Generator[None, None, None]:
 
 
 @contextlib.contextmanager
-def _unstaged_changes_cleared(patch_dir: str) -> Generator[None, None, None]:
+def _unstaged_changes_cleared(patch_dir: str) -> Generator[None]:
     tree = cmd_output('git', 'write-tree')[1].strip()
-    retcode, diff_stdout_binary, _ = cmd_output_b(
+    diff_cmd = (
         'git', 'diff-index', '--ignore-submodules', '--binary',
         '--exit-code', '--no-color', '--no-ext-diff', tree, '--',
-        check=False,
     )
-    if retcode and diff_stdout_binary.strip():
+    retcode, diff_stdout, diff_stderr = cmd_output_b(*diff_cmd, check=False)
+    if retcode == 0:
+        # There weren't any staged files so we don't need to do anything
+        # special
+        yield
+    elif retcode == 1 and not diff_stdout.strip():
+        # due to behaviour (probably a bug?) in git with crlf endings and
+        # autocrlf set to either `true` or `input` sometimes git will refuse
+        # to show a crlf-only diff to us :(
+        yield
+    elif retcode == 1 and diff_stdout.strip():
         patch_filename = f'patch{int(time.time())}-{os.getpid()}'
         patch_filename = os.path.join(patch_dir, patch_filename)
         logger.warning('Unstaged files detected.')
@@ -62,7 +72,7 @@ def _unstaged_changes_cleared(patch_dir: str) -> Generator[None, None, None]:
         # Save the current unstaged changes as a patch
         os.makedirs(patch_dir, exist_ok=True)
         with open(patch_filename, 'wb') as patch_file:
-            patch_file.write(diff_stdout_binary)
+            patch_file.write(diff_stdout)
 
         # prevent recursive post-checkout hooks (#1418)
         no_checkout_env = dict(os.environ, _PRE_COMMIT_SKIP_POST_CHECKOUT='1')
@@ -86,14 +96,16 @@ def _unstaged_changes_cleared(patch_dir: str) -> Generator[None, None, None]:
                 _git_apply(patch_filename)
 
             logger.info(f'Restored changes from {patch_filename}.')
-    else:
+    else:  # pragma: win32 no cover
-        # There weren't any staged files so we don't need to do anything
+        # some error occurred while requesting the diff
-        # special
+        e = CalledProcessError(retcode, diff_cmd, b'', diff_stderr)
-        yield
+        raise FatalError(
+            f'pre-commit failed to diff -- perhaps due to permissions?\n\n{e}',
+        )
 
 
 @contextlib.contextmanager
-def staged_files_only(patch_dir: str) -> Generator[None, None, None]:
+def staged_files_only(patch_dir: str) -> Generator[None]:
     """Clear any unstaged changes from the git working directory inside this
     context.
     """

pre_commit/store.py

@@ -5,18 +5,18 @@ import logging
 import os.path
 import sqlite3
 import tempfile
-from typing import Callable
+from collections.abc import Callable
-from typing import Generator
+from collections.abc import Generator
-from typing import Sequence
+from collections.abc import Sequence
 
 import pre_commit.constants as C
+from pre_commit import clientlib
 from pre_commit import file_lock
 from pre_commit import git
 from pre_commit.util import CalledProcessError
 from pre_commit.util import clean_path_on_failure
 from pre_commit.util import cmd_output_b
 from pre_commit.util import resource_text
-from pre_commit.util import rmtree
 
 
 logger = logging.getLogger('pre_commit')
@@ -95,13 +95,13 @@ class Store:
                     '    PRIMARY KEY (repo, ref)'
                     ');',
                 )
-                self._create_config_table(db)
+                self._create_configs_table(db)
 
             # Atomic file move
             os.replace(tmpfile, self.db_path)
 
     @contextlib.contextmanager
-    def exclusive_lock(self) -> Generator[None, None, None]:
+    def exclusive_lock(self) -> Generator[None]:
         def blocked_cb() -> None:  # pragma: no cover (tests are in-process)
             logger.info('Locking pre-commit directory')
 
@@ -112,7 +112,7 @@ class Store:
     def connect(
             self,
             db_path: str | None = None,
-    ) -> Generator[sqlite3.Connection, None, None]:
+    ) -> Generator[sqlite3.Connection]:
         db_path = db_path or self.db_path
         # sqlite doesn't close its fd with its contextmanager >.<
         # contextlib.closing fixes this.
@@ -125,7 +125,7 @@ class Store:
     @classmethod
     def db_repo_name(cls, repo: str, deps: Sequence[str]) -> str:
         if deps:
-            return f'{repo}:{",".join(sorted(deps))}'
+            return f'{repo}:{",".join(deps)}'
         else:
             return repo
 
@@ -136,6 +136,7 @@ class Store:
             deps: Sequence[str],
             make_strategy: Callable[[str], None],
     ) -> str:
+        original_repo = repo
         repo = self.db_repo_name(repo, deps)
 
         def _get_result() -> str | None:
@@ -168,6 +169,9 @@ class Store:
                     'INSERT INTO repos (repo, ref, path) VALUES (?, ?, ?)',
                     [repo, ref, directory],
                 )
+
+            clientlib.warn_for_stages_on_repo_init(original_repo, directory)
+
         return directory
 
     def _complete_clone(self, ref: str, git_cmd: Callable[..., None]) -> None:
@@ -210,7 +214,7 @@ class Store:
             'local', C.LOCAL_REPO_VERSION, deps, _make_local_repo,
         )
 
-    def _create_config_table(self, db: sqlite3.Connection) -> None:
+    def _create_configs_table(self, db: sqlite3.Connection) -> None:
         db.executescript(
             'CREATE TABLE IF NOT EXISTS configs ('
             '   path TEXT NOT NULL,'
@@ -227,28 +231,5 @@ class Store:
             return
         with self.connect() as db:
             # TODO: eventually remove this and only create in _create
-            self._create_config_table(db)
+            self._create_configs_table(db)
             db.execute('INSERT OR IGNORE INTO configs VALUES (?)', (path,))
-
-    def select_all_configs(self) -> list[str]:
-        with self.connect() as db:
-            self._create_config_table(db)
-            rows = db.execute('SELECT path FROM configs').fetchall()
-            return [path for path, in rows]
-
-    def delete_configs(self, configs: list[str]) -> None:
-        with self.connect() as db:
-            rows = [(path,) for path in configs]
-            db.executemany('DELETE FROM configs WHERE path = ?', rows)
-
-    def select_all_repos(self) -> list[tuple[str, str, str]]:
-        with self.connect() as db:
-            return db.execute('SELECT repo, ref, path from repos').fetchall()
-
-    def delete_repo(self, db_repo_name: str, ref: str, path: str) -> None:
-        with self.connect() as db:
-            db.execute(
-                'DELETE FROM repos WHERE repo = ? and ref = ?',
-                (db_repo_name, ref),
-            )
-        rmtree(path)

pre_commit/util.py

@@ -8,11 +8,10 @@ import shutil
 import stat
 import subprocess
 import sys
+from collections.abc import Callable
+from collections.abc import Generator
 from types import TracebackType
 from typing import Any
-from typing import Callable
-from typing import Generator
-from typing import IO
 
 from pre_commit import parse_shebang
 
@@ -26,7 +25,7 @@ def force_bytes(exc: Any) -> bytes:
 
 
 @contextlib.contextmanager
-def clean_path_on_failure(path: str) -> Generator[None, None, None]:
+def clean_path_on_failure(path: str) -> Generator[None]:
     """Cleans up the directory on an exceptional failure."""
     try:
         yield
@@ -36,12 +35,9 @@ def clean_path_on_failure(path: str) -> Generator[None, None, None]:
         raise
 
 
-def resource_bytesio(filename: str) -> IO[bytes]:
-    return importlib.resources.open_binary('pre_commit.resources', filename)
-
-
 def resource_text(filename: str) -> str:
-    return importlib.resources.read_text('pre_commit.resources', filename)
+    files = importlib.resources.files('pre_commit.resources')
+    return files.joinpath(filename).read_text()
 
 
 def make_executable(filename: str) -> None:
@@ -67,7 +63,7 @@ class CalledProcessError(RuntimeError):
     def __bytes__(self) -> bytes:
         def _indent_or_none(part: bytes | None) -> bytes:
             if part:
-                return b'\n    ' + part.replace(b'\n', b'\n    ')
+                return b'\n    ' + part.replace(b'\n', b'\n    ').rstrip()
             else:
                 return b' (none)'
 
@@ -124,7 +120,7 @@ def cmd_output(*cmd: str, **kwargs: Any) -> tuple[int, str, str | None]:
     return returncode, stdout, stderr
 
 
-if os.name != 'nt':  # pragma: win32 no cover
+if sys.platform != 'win32':  # pragma: win32 no cover
     from os import openpty
     import termios
 
@@ -206,24 +202,37 @@ else:  # pragma: no cover
     cmd_output_p = cmd_output_b
 
 
-def rmtree(path: str) -> None:
+def _handle_readonly(
-    """On windows, rmtree fails for readonly dirs."""
+        func: Callable[[str], object],
-    def handle_remove_readonly(
+        path: str,
-            func: Callable[..., Any],
+        exc: BaseException,
-            path: str,
+) -> None:
-            exc: tuple[type[OSError], OSError, TracebackType],
+    if (
+            func in (os.rmdir, os.remove, os.unlink) and
+            isinstance(exc, OSError) and
+            exc.errno in {errno.EACCES, errno.EPERM}
+    ):
+        for p in (path, os.path.dirname(path)):
+            os.chmod(p, os.stat(p).st_mode | stat.S_IWUSR)
+        func(path)
+    else:
+        raise
+
+
+if sys.version_info < (3, 12):  # pragma: <3.12 cover
+    def _handle_readonly_old(
+        func: Callable[[str], object],
+        path: str,
+        excinfo: tuple[type[BaseException], BaseException, TracebackType],
     ) -> None:
-        excvalue = exc[1]
+        return _handle_readonly(func, path, excinfo[1])
-        if (
+
-                func in (os.rmdir, os.remove, os.unlink) and
+    def rmtree(path: str) -> None:
-                excvalue.errno in {errno.EACCES, errno.EPERM}
+        shutil.rmtree(path, ignore_errors=False, onerror=_handle_readonly_old)
-        ):
+else:  # pragma: >=3.12 cover
-            for p in (path, os.path.dirname(path)):
+    def rmtree(path: str) -> None:
-                os.chmod(p, os.stat(p).st_mode | stat.S_IWUSR)
+        """On windows, rmtree fails for readonly dirs."""
-            func(path)
+        shutil.rmtree(path, ignore_errors=False, onexc=_handle_readonly)
-        else:
-            raise
-    shutil.rmtree(path, ignore_errors=False, onerror=handle_remove_readonly)
 
 
 def win_exe(s: str) -> str:

pre_commit/xargs.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import concurrent.futures
 import contextlib
 import math
+import multiprocessing
 import os
 import subprocess
 import sys
+from collections.abc import Callable
+from collections.abc import Generator
+from collections.abc import Iterable
+from collections.abc import MutableMapping
+from collections.abc import Sequence
 from typing import Any
-from typing import Callable
-from typing import Generator
-from typing import Iterable
-from typing import MutableMapping
-from typing import Sequence
 from typing import TypeVar
 
 from pre_commit import parse_shebang
@@ -22,6 +23,21 @@ TArg = TypeVar('TArg')
 TRet = TypeVar('TRet')
 
 
+def cpu_count() -> int:
+    try:
+        # On systems that support it, this will return a more accurate count of
+        # usable CPUs for the current process, which will take into account
+        # cgroup limits
+        return len(os.sched_getaffinity(0))
+    except AttributeError:
+        pass
+
+    try:
+        return multiprocessing.cpu_count()
+    except NotImplementedError:
+        return 1
+
+
 def _environ_size(_env: MutableMapping[str, str] | None = None) -> int:
     environ = _env if _env is not None else getattr(os, 'environb', os.environ)
     size = 8 * len(environ)  # number of pointers in `envp`
@@ -104,7 +120,6 @@ def partition(
 @contextlib.contextmanager
 def _thread_mapper(maxsize: int) -> Generator[
     Callable[[Callable[[TArg], TRet], Iterable[TArg]], Iterable[TRet]],
-    None, None,
 ]:
     if maxsize == 1:
         yield map
@@ -162,7 +177,8 @@ def xargs(
         results = thread_map(run_cmd_partition, partitions)
 
         for proc_retcode, proc_out, _ in results:
-            retcode = max(retcode, proc_retcode)
+            if abs(proc_retcode) > abs(retcode):
+                retcode = proc_retcode
             stdout += proc_out
 
     return retcode, stdout

pre_commit/yaml.py

@@ -6,6 +6,7 @@ from typing import Any
 import yaml
 
 Loader = getattr(yaml, 'CSafeLoader', yaml.SafeLoader)
+yaml_compose = functools.partial(yaml.compose, Loader=Loader)
 yaml_load = functools.partial(yaml.load, Loader=Loader)
 Dumper = getattr(yaml, 'CSafeDumper', yaml.SafeDumper)
 

pre_commit/yaml_rewrite.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from collections.abc import Iterable
+from typing import NamedTuple
+from typing import Protocol
+
+from yaml.nodes import MappingNode
+from yaml.nodes import Node
+from yaml.nodes import ScalarNode
+from yaml.nodes import SequenceNode
+
+
+class _Matcher(Protocol):
+    def match(self, n: Node) -> Generator[Node]: ...
+
+
+class MappingKey(NamedTuple):
+    k: str
+
+    def match(self, n: Node) -> Generator[Node]:
+        if isinstance(n, MappingNode):
+            for k, _ in n.value:
+                if k.value == self.k:
+                    yield k
+
+
+class MappingValue(NamedTuple):
+    k: str
+
+    def match(self, n: Node) -> Generator[Node]:
+        if isinstance(n, MappingNode):
+            for k, v in n.value:
+                if k.value == self.k:
+                    yield v
+
+
+class SequenceItem(NamedTuple):
+    def match(self, n: Node) -> Generator[Node]:
+        if isinstance(n, SequenceNode):
+            yield from n.value
+
+
+def _match(gen: Iterable[Node], m: _Matcher) -> Iterable[Node]:
+    return (n for src in gen for n in m.match(src))
+
+
+def match(n: Node, matcher: tuple[_Matcher, ...]) -> Generator[ScalarNode]:
+    gen: Iterable[Node] = (n,)
+    for m in matcher:
+        gen = _match(gen, m)
+    return (n for n in gen if isinstance(n, ScalarNode))

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pre_commit
-version = 3.0.2
+version = 4.5.1
 description = A framework for managing and maintaining multi-language pre-commit hooks.
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -8,9 +8,8 @@ url = https://github.com/pre-commit/pre-commit
 author = Anthony Sottile
 author_email = asottile@umich.edu
 license = MIT
-license_file = LICENSE
+license_files = LICENSE
 classifiers =
-    License :: OSI Approved :: MIT License
     Programming Language :: Python :: 3
     Programming Language :: Python :: 3 :: Only
     Programming Language :: Python :: Implementation :: CPython
@@ -24,7 +23,7 @@ install_requires =
     nodeenv>=0.11.1
     pyyaml>=5.1
     virtualenv>=20.10.0
-python_requires = >=3.8
+python_requires = >=3.10
 
 [options.packages.find]
 exclude =
@@ -53,6 +52,7 @@ check_untyped_defs = true
 disallow_any_generics = true
 disallow_incomplete_defs = true
 disallow_untyped_defs = true
+enable_error_code = deprecated
 warn_redundant_casts = true
 warn_unused_ignores = true
 

testing/get-dart.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-VERSION=2.13.4
+VERSION=2.19.6
 
 if [ "$OSTYPE" = msys ]; then
     URL="https://storage.googleapis.com/dart-archive/channels/stable/release/${VERSION}/sdk/dartsdk-windows-x64-release.zip"

testing/get-swift.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# This is a script used in CI to install swift
-set -euo pipefail
-
-. /etc/lsb-release
-if [ "$DISTRIB_CODENAME" = "jammy" ]; then
-    SWIFT_URL='https://download.swift.org/swift-5.7.1-release/ubuntu2204/swift-5.7.1-RELEASE/swift-5.7.1-RELEASE-ubuntu22.04.tar.gz'
-    SWIFT_HASH='7f60291f5088d3e77b0c2364beaabd29616ee7b37260b7b06bdbeb891a7fe161'
-else
-    echo "unknown dist: ${DISTRIB_CODENAME}" 1>&2
-    exit 1
-fi
-
-check() {
-    echo "$SWIFT_HASH  $TGZ" | sha256sum --check
-}
-
-TGZ="$HOME/.swift/swift.tar.gz"
-mkdir -p "$(dirname "$TGZ")"
-if ! check >& /dev/null; then
-    rm -f "$TGZ"
-    curl --location --silent --output "$TGZ" "$SWIFT_URL"
-    check
-fi
-
-mkdir -p /tmp/swift
-tar -xf "$TGZ" --strip 1 --directory /tmp/swift
-
-echo '/tmp/swift/usr/bin' >> "$GITHUB_PATH"

testing/language_helpers.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
 import os
-from typing import Sequence
+from collections.abc import Sequence
 
-import pre_commit.constants as C
+from pre_commit.lang_base import Language
-from pre_commit.languages.all import Language
 from pre_commit.prefix import Prefix
 
 
@@ -14,13 +13,19 @@ def run_language(
         exe: str,
         args: Sequence[str] = (),
         file_args: Sequence[str] = (),
-        version: str = C.DEFAULT,
+        version: str | None = None,
         deps: Sequence[str] = (),
         is_local: bool = False,
+        require_serial: bool = True,
+        color: bool = False,
 ) -> tuple[int, bytes]:
     prefix = Prefix(str(path))
+    version = version or language.get_default_version()
 
-    language.install_environment(prefix, version, deps)
+    if language.ENVIRONMENT_DIR is not None:
+        language.install_environment(prefix, version, deps)
+        health_error = language.health_check(prefix, version)
+        assert health_error is None, health_error
     with language.in_env(prefix, version):
         ret, out = language.run_hook(
             prefix,
@@ -28,8 +33,8 @@ def run_language(
             args,
             file_args,
             is_local=is_local,
-            require_serial=True,
+            require_serial=require_serial,
-            color=False,
+            color=color,
         )
         out = out.replace(b'\r\n', b'\n')
         return ret, out

testing/languages

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import json
+import os.path
+import subprocess
+import sys
+
+EXCLUDED = frozenset((
+    ('windows-latest', 'docker'),
+    ('windows-latest', 'docker_image'),
+    ('windows-latest', 'lua'),
+    ('windows-latest', 'swift'),
+))
+
+
+def _always_run() -> frozenset[str]:
+    ret = ['.github/workflows/languages.yaml', 'testing/languages']
+    ret.extend(
+        os.path.join('pre_commit/resources', fname)
+        for fname in os.listdir('pre_commit/resources')
+    )
+    return frozenset(ret)
+
+
+def _lang_files(lang: str) -> frozenset[str]:
+    prog = f'''\
+import json
+import os.path
+import sys
+
+import pre_commit.languages.{lang}
+import tests.languages.{lang}_test
+
+modules = sorted(
+    os.path.relpath(v.__file__)
+    for k, v in sys.modules.items()
+    if k.startswith(('pre_commit.', 'tests.', 'testing.'))
+)
+print(json.dumps(modules))
+'''
+    out = json.loads(subprocess.check_output((sys.executable, '-c', prog)))
+    return frozenset(out)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--all', action='store_true')
+    args = parser.parse_args()
+
+    langs = [
+        os.path.splitext(fname)[0]
+        for fname in sorted(os.listdir('pre_commit/languages'))
+        if fname.endswith('.py') and fname != '__init__.py'
+    ]
+
+    triggers_all = _always_run()
+    for fname in triggers_all:
+        assert os.path.exists(fname), fname
+
+    if not args.all:
+        with concurrent.futures.ThreadPoolExecutor(os.cpu_count()) as exe:
+            by_lang = {
+                lang: files | triggers_all
+                for lang, files in zip(langs, exe.map(_lang_files, langs))
+            }
+
+        diff_cmd = ('git', 'diff', '--name-only', 'origin/main...HEAD')
+        files = set(subprocess.check_output(diff_cmd).decode().splitlines())
+
+        langs = [
+            lang
+            for lang, lang_files in by_lang.items()
+            if lang_files & files
+        ]
+
+    matched = [
+        {'os': os, 'language': lang}
+        for os in ('windows-latest', 'ubuntu-latest')
+        for lang in langs
+        if (os, lang) not in EXCLUDED
+    ]
+
+    with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
+        f.write(f'languages={json.dumps(matched)}\n')
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

testing/make-archives

@@ -8,7 +8,7 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
-from typing import Sequence
+from collections.abc import Sequence
 
 
 # This is a script for generating the tarred resources for git repo
@@ -16,8 +16,8 @@ from typing import Sequence
 
 
 REPOS = (
-    ('rbenv', 'https://github.com/rbenv/rbenv', '38e1fbb'),
+    ('rbenv', 'https://github.com/rbenv/rbenv', '10e96bfc'),
-    ('ruby-build', 'https://github.com/rbenv/ruby-build', '9d92a69'),
+    ('ruby-build', 'https://github.com/rbenv/ruby-build', '447468b1'),
     (
         'ruby-download',
         'https://github.com/garnieretienne/rvm-download',
@@ -57,8 +57,7 @@ def make_archive(name: str, repo: str, ref: str, destdir: str) -> str:
         arcs.sort()
 
         with gzip.GzipFile(output_path, 'wb', mtime=0) as gzipf:
-            # https://github.com/python/typeshed/issues/5491
+            with tarfile.open(fileobj=gzipf, mode='w') as tf:
-            with tarfile.open(fileobj=gzipf, mode='w') as tf:  # type: ignore
                 for arcname, abspath in arcs:
                     tf.add(
                         abspath,

testing/resources/docker_hooks_repo/.pre-commit-hooks.yaml

@@ -1,17 +0,0 @@
--   id: docker-hook
-    name: Docker test hook
-    entry: echo
-    language: docker
-    files: \.txt$
-
--   id: docker-hook-arg
-    name: Docker test hook
-    entry: echo -n
-    language: docker
-    files: \.txt$
-
--   id: docker-hook-failing
-    name: Docker test hook with nonzero exit code
-    entry: bork
-    language: docker
-    files: \.txt$

testing/resources/docker_hooks_repo/Dockerfile

@@ -1,3 +0,0 @@
-FROM ubuntu:focal
-
-CMD ["echo", "This is overwritten by the .pre-commit-hooks.yaml 'entry'"]

testing/resources/docker_image_hooks_repo/.pre-commit-hooks.yaml

@@ -1,8 +0,0 @@
--   id: echo-entrypoint
-    name: echo (via --entrypoint)
-    language: docker_image
-    entry: --entrypoint echo ubuntu:focal
--   id: echo-cmd
-    name: echo (via cmd)
-    language: docker_image
-    entry: ubuntu:focal echo

testing/resources/dotnet_hooks_combo_repo/.pre-commit-hooks.yaml

@@ -1,12 +0,0 @@
--   id: dotnet-example-hook
-    name: Test Project 1
-    description: Test Project 1
-    entry: proj1
-    language: dotnet
-    stages: [commit]
--   id: proj2
-    name: Test Project 2
-    description: Test Project 2
-    entry: proj2
-    language: dotnet
-    stages: [commit]

testing/resources/dotnet_hooks_combo_repo/dotnet_hooks_combo_repo.sln

@@ -1,28 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30114.105
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "proj1", "proj1\proj1.csproj", "{38A939C3-DEA4-47D7-9B75-0418C4249662}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "proj2", "proj2\proj2.csproj", "{4C9916CB-165C-4EF5-8A57-4CB6794C1EBF}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{38A939C3-DEA4-47D7-9B75-0418C4249662}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{38A939C3-DEA4-47D7-9B75-0418C4249662}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{38A939C3-DEA4-47D7-9B75-0418C4249662}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{38A939C3-DEA4-47D7-9B75-0418C4249662}.Release|Any CPU.Build.0 = Release|Any CPU
-		{4C9916CB-165C-4EF5-8A57-4CB6794C1EBF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4C9916CB-165C-4EF5-8A57-4CB6794C1EBF}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4C9916CB-165C-4EF5-8A57-4CB6794C1EBF}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4C9916CB-165C-4EF5-8A57-4CB6794C1EBF}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal

testing/resources/dotnet_hooks_combo_repo/proj1/Program.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace proj1
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.Write("Hello from dotnet!\n");
-        }
-    }
-}

testing/resources/dotnet_hooks_combo_repo/proj1/proj1.csproj

@@ -1,12 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6</TargetFramework>
-
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>proj1</ToolCommandName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
-  </PropertyGroup>
-
-</Project>

testing/resources/dotnet_hooks_combo_repo/proj2/Program.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace proj2
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.WriteLine("Hello World!");
-        }
-    }
-}

testing/resources/dotnet_hooks_combo_repo/proj2/proj2.csproj

@@ -1,12 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6</TargetFramework>
-
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>proj2</ToolCommandName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
-  </PropertyGroup>
-
-</Project>

testing/resources/dotnet_hooks_csproj_prefix_repo/.gitignore

@@ -1,3 +0,0 @@
-bin/
-obj/
-nupkg/

testing/resources/dotnet_hooks_csproj_prefix_repo/.pre-commit-hooks.yaml

@@ -1,5 +0,0 @@
--   id: dotnet-example-hook
-    name: dotnet example hook
-    entry: testeroni.tool
-    language: dotnet
-    files: ''

testing/resources/dotnet_hooks_csproj_prefix_repo/Program.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace dotnet_hooks_repo
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.WriteLine("Hello from dotnet!");
-        }
-    }
-}

testing/resources/dotnet_hooks_csproj_prefix_repo/dotnet_hooks_csproj_prefix_repo.csproj

@@ -1,9 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>testeroni.tool</ToolCommandName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
-  </PropertyGroup>
-</Project>

testing/resources/dotnet_hooks_csproj_repo/.gitignore

@@ -1,3 +0,0 @@
-bin/
-obj/
-nupkg/

testing/resources/dotnet_hooks_csproj_repo/.pre-commit-hooks.yaml

@@ -1,5 +0,0 @@
--   id: dotnet-example-hook
-    name: dotnet example hook
-    entry: testeroni
-    language: dotnet
-    files: ''

testing/resources/dotnet_hooks_csproj_repo/Program.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace dotnet_hooks_repo
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.WriteLine("Hello from dotnet!");
-        }
-    }
-}

testing/resources/dotnet_hooks_csproj_repo/dotnet_hooks_csproj_repo.csproj

@@ -1,9 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6</TargetFramework>
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>testeroni</ToolCommandName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
-  </PropertyGroup>
-</Project>

testing/resources/dotnet_hooks_sln_repo/.gitignore

@@ -1,3 +0,0 @@
-bin/
-obj/
-nupkg/

testing/resources/dotnet_hooks_sln_repo/.pre-commit-hooks.yaml

@@ -1,5 +0,0 @@
--   id: dotnet-example-hook
-    name: dotnet example hook
-    entry: testeroni
-    language: dotnet
-    files: ''

testing/resources/dotnet_hooks_sln_repo/Program.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace dotnet_hooks_sln_repo
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-            Console.WriteLine("Hello from dotnet!");
-        }
-    }
-}

testing/resources/dotnet_hooks_sln_repo/dotnet_hooks_sln_repo.csproj

@@ -1,9 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6</TargetFramework>
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>testeroni</ToolCommandName>
-    <PackageOutputPath>./nupkg</PackageOutputPath>
-  </PropertyGroup>
-</Project>

testing/resources/dotnet_hooks_sln_repo/dotnet_hooks_sln_repo.sln

@@ -1,34 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.26124.0
-MinimumVisualStudioVersion = 15.0.26124.0
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "dotnet_hooks_sln_repo", "dotnet_hooks_sln_repo.csproj", "{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|Any CPU = Release|Any CPU
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|x64.Build.0 = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Debug|x86.Build.0 = Debug|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|x64.ActiveCfg = Release|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|x64.Build.0 = Release|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|x86.ActiveCfg = Release|Any CPU
-		{6568CFDB-6F6F-45A9-932C-8C7DAABC8E56}.Release|x86.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal

testing/resources/golang_hooks_repo/.pre-commit-hooks.yaml

@@ -1,5 +0,0 @@
--   id: golang-hook
-    name: golang example hook
-    entry: golang-hello-world
-    language: golang
-    files: ''

testing/resources/golang_hooks_repo/go.mod

@@ -1,5 +0,0 @@
-module golang-hello-world
-
-go 1.18
-
-require github.com/BurntSushi/toml v1.1.0

testing/resources/golang_hooks_repo/go.sum

@@ -1,2 +0,0 @@
-github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
-github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=

testing/resources/golang_hooks_repo/golang-hello-world/main.go

@@ -1,23 +0,0 @@
-package main
-
-
-import (
-	"fmt"
-	"runtime"
-	"github.com/BurntSushi/toml"
-	"os"
-)
-
-type Config struct {
-	What string
-}
-
-func main() {
-	message := runtime.Version()
-	if len(os.Args) > 1 {
-		message = os.Args[1]
-	}
-	var conf Config
-	toml.Decode("What = 'world'\n", &conf)
-	fmt.Printf("hello %v from %s\n", conf.What, message)
-}