Bump version to 0.0.263 (#4086)

* Use crates.io version of pep440_rs

* Update Cargo.lock

.cargo/config.toml

@@ -1,5 +1,6 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
+benchmark = "bench -p ruff_benchmark --"
 
 [target.'cfg(all())']
 rustflags = [
@@ -25,4 +26,11 @@ rustflags = [
   "-Wclippy::print_stdout",
   "-Wclippy::print_stderr",
   "-Wclippy::dbg_macro",
+  "-Wclippy::empty_drop",
+  "-Wclippy::empty_structs_with_brackets",
+  "-Wclippy::exit",
+  "-Wclippy::get_unwrap",
+  "-Wclippy::rc_buffer",
+  "-Wclippy::rc_mutex",
+  "-Wclippy::rest_pat_in_fully_bound_structs",
 ]

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "12:00"
+      timezone: "America/New_York"
+    commit-message:
+      prefix: "ci(deps)"

.github/workflows/benchmark.yaml

@@ -0,0 +1,135 @@
+name: Benchmark
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  run-benchmark:
+    if: github.event_name == 'pull_request'
+    name: "Run | ${{ matrix.os }}"
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: "PR - Checkout Branch"
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: "PR - Install Rust toolchain"
+        run: rustup show
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: "PR - Build benchmarks"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -p ruff_benchmark --no-run
+
+      - name: "PR - Run benchmarks"
+        run: cargo benchmark --save-baseline=pr
+
+      - name: "Main - Checkout Branch"
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          ref: main
+
+      - name: "Main - Install Rust toolchain"
+        run: rustup show
+
+      - name: "Main - Build benchmarks"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -p ruff_benchmark --no-run
+
+      - name: "Main - Run benchmarks"
+        run: cargo benchmark --save-baseline=main
+
+      - name: "Upload benchmark results"
+        uses: actions/upload-artifact@v3
+        with:
+          name: benchmark-results-${{ matrix.os }}
+          path: ./target/criterion
+
+      # Cleanup
+      - name: Remove Criterion Artifact
+        uses: JesseTG/rm@v1.0.3
+        with:
+          path: ./target/criterion
+
+  benchmark-compare:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    name: Compare
+    needs:
+      - run-benchmark
+
+    steps:
+      - name: "Install Rust toolchain"
+        run: rustup show
+
+      - name: "Install cargo-binstall"
+        uses: taiki-e/install-action@cargo-binstall
+
+      - name: "Install critcmp"
+        run: cargo binstall critcmp -y
+
+      - name: "Linux | Download PR benchmark results"
+        uses: actions/download-artifact@v3
+        with:
+          name: benchmark-results-ubuntu-latest
+          path: ./target/criterion
+
+      - name: "Linux | Compare benchmark results"
+        shell: bash
+        run: |
+          echo "### Benchmark" >> summary.md
+          echo "#### Linux" >> summary.md
+          echo "\`\`\`" >> summary.md
+          critcmp main pr >> summary.md
+          echo "\`\`\`" >> summary.md
+          echo "" >> summary.md
+
+      - name: "Linux | Cleanup benchmark results"
+        run: rm -rf ./target/criterion
+
+      - name: "Windows | Download PR benchmark results"
+        uses: actions/download-artifact@v3
+        with:
+          name: benchmark-results-windows-latest
+          path: ./target/criterion
+
+      - name: "Windows | Compare benchmark results"
+        shell: bash
+        run: |
+          echo "#### Windows" >> summary.md
+          echo "\`\`\`" >> summary.md
+          critcmp main pr >> summary.md
+          echo "\`\`\`" >> summary.md
+          echo "" >> summary.md
+
+          echo ${{ github.event.pull_request.number }} > pr-number
+
+          cat summary.md > $GITHUB_STEP_SUMMARY
+
+      - uses: actions/upload-artifact@v3
+        name: Upload PR Number
+        with:
+          name: pr-number
+          path: pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload Summary
+        with:
+          name: summary
+          path: summary.md

.github/workflows/ci.yaml

@@ -17,20 +17,6 @@ env:
   RUSTUP_MAX_RETRIES: 10
 
 jobs:
-  cargo-build:
-    name: "cargo build"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - uses: Swatinem/rust-cache@v1
-      - run: cargo build --all
-      - run: ./target/debug/ruff_dev generate-all
-      - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. Run 'cargo dev generate-all'."
-      - run: git diff --quiet ruff.schema.json || echo "::error file=ruff.schema.json::This file is outdated. Run 'cargo dev generate-all'."
-      - run: git diff --exit-code -- README.md ruff.schema.json
-
   cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
@@ -48,7 +34,7 @@ jobs:
       - name: "Install Rust toolchain"
         run: |
           rustup component add clippy
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
       - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
   cargo-clippy-wasm:
@@ -60,8 +46,8 @@ jobs:
         run: |
           rustup component add clippy
           rustup target add wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v1
-      - run: cargo clippy -p ruff --target wasm32-unknown-unknown --all-features -- -D warnings
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy -p ruff_wasm --target wasm32-unknown-unknown --all-features -- -D warnings
 
   cargo-test:
     strategy:
@@ -73,9 +59,9 @@ jobs:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"
         run: rustup show
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
       - run: cargo install cargo-insta
-      - run: pip install black[d]==22.12.0
+      - run: pip install black[d]==23.1.0
       - name: "Run tests (Ubuntu)"
         if: ${{ matrix.os == 'ubuntu-latest' }}
         run: |
@@ -93,6 +79,30 @@ jobs:
         env:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
+      - uses: actions/upload-artifact@v3
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        with:
+          name: ruff
+          path: target/debug/ruff
+
+  cargo-test-wasm:
+    runs-on: ubuntu-latest
+    name: "cargo test (wasm)"
+    steps:
+      - uses: actions/checkout@v3
+      - name: "Install Rust toolchain"
+        run: rustup target add wasm32-unknown-unknown
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: "npm"
+          cache-dependency-path: playground/package-lock.json
+      - uses: jetli/wasm-pack-action@v0.4.0
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run wasm-pack"
+        run: |
+          cd crates/ruff_wasm
+          wasm-pack test --node
 
   scripts:
     name: "test scripts"
@@ -100,29 +110,16 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"
-        run: rustup show
-      - uses: Swatinem/rust-cache@v1
-      - run: ./scripts/add_rule.py --name DoTheThing --code PLC999 --linter pylint
+        run: rustup component add rustfmt
+      - uses: Swatinem/rust-cache@v2
+      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
       - run: cargo check
+      - run: cargo fmt --all --check
       - run: |
           ./scripts/add_plugin.py test --url https://pypi.org/project/-test/0.1.0/ --prefix TST
-          ./scripts/add_rule.py --name FirstRule --code TST001 --linter test
+          ./scripts/add_rule.py --name FirstRule --prefix TST --code 001 --linter test
       - run: cargo check
-
-  maturin-build:
-    name: "maturin build"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - uses: Swatinem/rust-cache@v1
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.11"
-      - run: pip install maturin
-      - run: maturin build -b bin
-      - run: python scripts/transform_readme.py --target pypi
+      - run: cargo fmt --all --check
 
   typos:
     name: "spell check"
@@ -132,3 +129,104 @@ jobs:
       - uses: crate-ci/typos@master
         with:
           files: .
+
+  ecosystem:
+    name: "ecosystem"
+    runs-on: ubuntu-latest
+    needs: cargo-test
+    # Only runs on pull requests, since that is the only we way we can find the base version for comparison.
+    if: github.event_name == 'pull_request'
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+
+      - uses: actions/download-artifact@v3
+        name: Download Ruff binary
+        id: ruff-target
+        with:
+          name: ruff
+          path: target/debug
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: Download base results
+        with:
+          name: ruff
+          branch: ${{ github.event.pull_request.base.ref }}
+          check_artifacts: true
+
+      - name: Run ecosystem check
+        run: |
+          # Make executable, since artifact download doesn't preserve this
+          chmod +x ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+
+          scripts/check_ecosystem.py ruff ${{ steps.ruff-target.outputs.download-path }}/ruff | tee ecosystem-result
+          cat ecosystem-result > $GITHUB_STEP_SUMMARY
+
+          echo ${{ github.event.number }} > pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload PR Number
+        with:
+          name: pr-number
+          path: pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload Results
+        with:
+          name: ecosystem-result
+          path: ecosystem-result
+
+  cargo-udeps:
+    name: "cargo udeps"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: "Install nightly Rust toolchain"
+        # Only pinned to make caching work, update freely
+        run: rustup toolchain install nightly-2023-03-30
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install cargo-udeps"
+        uses: taiki-e/install-action@cargo-udeps
+      - name: "Run cargo-udeps"
+        run: |
+          unused_dependencies=$(cargo +nightly-2023-03-30 udeps > unused.txt && cat unused.txt | cut -d $'\n' -f 2-)
+          if [ -z "$unused_dependencies" ]; then
+            echo "No unused dependencies found" > $GITHUB_STEP_SUMMARY
+            exit 0
+          else
+            echo "Found unused dependencies" > $GITHUB_STEP_SUMMARY
+            echo '```console' >> $GITHUB_STEP_SUMMARY
+            echo "$unused_dependencies" >> $GITHUB_STEP_SUMMARY
+            echo '```' >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi
+
+  pre-commit:
+    name: "pre-commit"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install pre-commit"
+        run: pip install pre-commit
+      - name: "Cache pre-commit"
+        uses: actions/cache@v3
+        with:
+            path: ~/.cache/pre-commit
+            key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: "Run pre-commit"
+        run: |
+          echo '```console' > $GITHUB_STEP_SUMMARY
+          # Enable color output for pre-commit and remove it for the summary
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
+            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> $GITHUB_STEP_SUMMARY) >&1
+          exit_code=${PIPESTATUS[0]}
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          exit $exit_code

.github/workflows/docs.yaml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/setup-python@v4
       - name: "Install Rust toolchain"
         run: rustup show
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
       - name: "Install dependencies"
         run: |
           pip install -r docs/requirements.txt

.github/workflows/flake8-to-ruff.yaml

@@ -133,7 +133,7 @@ jobs:
           target: ${{ matrix.target }}
           manylinux: auto
           args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-      - uses: uraimo/run-on-arch-action@v2.5.0
+      - uses: uraimo/run-on-arch-action@v2
         if: matrix.target != 'ppc64'
         name: Install built wheel
         with:
@@ -206,7 +206,7 @@ jobs:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-      - uses: uraimo/run-on-arch-action@master
+      - uses: uraimo/run-on-arch-action@v2
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}

.github/workflows/playground.yaml

@@ -28,7 +28,7 @@ jobs:
       - uses: jetli/wasm-pack-action@v0.4.0
       - uses: jetli/wasm-bindgen-action@v0.2.0
       - name: "Run wasm-pack"
-        run: wasm-pack build --target web --out-dir ../../playground/src/pkg crates/ruff
+        run: wasm-pack build --target web --out-dir ../../playground/src/pkg crates/ruff_wasm
       - name: "Install Node dependencies"
         run: npm ci
         working-directory: playground

.github/workflows/pr-comment.yaml

@@ -0,0 +1,84 @@
+name: PR Check Comment
+
+on:
+  workflow_run:
+    workflows: [CI, Benchmark]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      workflow_run_id:
+        description: The ecosystem workflow that triggers the workflow run
+        required: true
+
+permissions:
+  pull-requests: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dawidd6/action-download-artifact@v2
+        name: Download PR Number
+        with:
+          name: pr-number
+          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
+          if_no_artifact_found: ignore
+
+      - name: Extract PR Number
+        id: pr-number
+        run: |
+          if [[ -f pr-number ]]
+          then
+            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
+          fi
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: "Download Ecosystem Result"
+        id: download-ecosystem-result
+        if: steps.pr-number.outputs.pr-number
+        with:
+          name: ecosystem-result
+          workflow: ci.yaml
+          pr: ${{ steps.pr-number.outputs.pr-number }}
+          path: pr/ecosystem
+          if_no_artifact_found: ignore
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: "Download Benchmark Result"
+        id: download-benchmark-result
+        if: steps.pr-number.outputs.pr-number
+        with:
+          name: summary
+          workflow: benchmark.yaml
+          pr: ${{ steps.pr-number.outputs.pr-number }}
+          path: pr/benchmark
+          if_no_artifact_found: ignore
+
+      - name: Generate Comment
+        id: generate-comment
+        if: steps.download-ecosystem-result.outputs.found_artifact == 'true' || steps.download-benchmark-result.outputs.found_artifact == 'true'
+        run: |
+          echo 'comment<<EOF' >> $GITHUB_OUTPUT
+          echo '## PR Check Results' >> $GITHUB_OUTPUT
+
+          if [[ -f pr/ecosystem/ecosystem-result ]]
+          then
+            echo "### Ecosystem" >> $GITHUB_OUTPUT
+            cat pr/ecosystem/ecosystem-result >> $GITHUB_OUTPUT
+            echo "" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f pr/benchmark/summary.md ]]
+          then
+            cat pr/benchmark/summary.md >> $GITHUB_OUTPUT
+          fi
+
+          echo 'EOF' >> $GITHUB_OUTPUT
+
+      - name: Create or update comment
+        if: steps.generate-comment.outputs.comment
+        uses: thollander/actions-comment-pull-request@v2
+        with:
+          pr_number: ${{ steps.pr-number.outputs.pr-number }}
+          message: ${{ steps.generate-comment.outputs.comment }}
+          comment_tag: PR Check Results

.github/workflows/ruff.yaml

@@ -208,7 +208,7 @@ jobs:
           target: ${{ matrix.platform.target }}
           manylinux: auto
           args: --release --out dist
-      - uses: uraimo/run-on-arch-action@v2.5.0
+      - uses: uraimo/run-on-arch-action@v2
         if: matrix.platform.arch != 'ppc64'
         name: Install built wheel
         with:
@@ -309,7 +309,7 @@ jobs:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist
-      - uses: uraimo/run-on-arch-action@master
+      - uses: uraimo/run-on-arch-action@v2
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}

.gitignore

@@ -3,6 +3,7 @@
 crates/ruff/resources/test/cpython
 mkdocs.yml
 .overrides
+github_search.jsonl
 
 ###
 # Rust.gitignore

.pre-commit-config.yaml

@@ -1,10 +1,18 @@
 fail_fast: true
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.10.1
+    rev: v0.12.1
     hooks:
       - id: validate-pyproject
 
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.16
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-black
+          - black==23.1.0 # Must be the latest version of Black
+
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.33.0
     hooks:
@@ -13,7 +21,6 @@ repos:
           - --disable
           - MD013 # line-length
           - MD033 # no-inline-html
-          - MD041 # first-line-h1
           - --
 
   - repo: local
@@ -21,17 +28,17 @@ repos:
       - id: cargo-fmt
         name: cargo fmt
         entry: cargo fmt --
-        language: rust
+        language: system
         types: [rust]
       - id: clippy
         name: clippy
         entry: cargo clippy --workspace --all-targets --all-features -- -D warnings
-        language: rust
+        language: system
         pass_filenames: false
       - id: ruff
         name: ruff
         entry: cargo run -p ruff_cli -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
-        language: rust
+        language: system
         types_or: [python, pyi]
         require_serial: true
         exclude: |
@@ -42,9 +49,20 @@ repos:
       - id: dev-generate-all
         name: dev-generate-all
         entry: cargo dev generate-all
-        language: rust
+        language: system
         pass_filenames: false
         exclude: target
 
+  # Black
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+        exclude: |
+          (?x)^(
+            crates/ruff/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
+
 ci:
   skip: [cargo-fmt, clippy, dev-generate-all]

BREAKING_CHANGES.md

@@ -1,5 +1,40 @@
 # Breaking Changes
 
+## 0.0.260
+
+### Fixes are now represented as a list of edits ([#3709](https://github.com/charliermarsh/ruff/pull/3709))
+
+Previously, Ruff represented each fix as a single edit, which prohibited Ruff from automatically
+fixing violations that required multiple edits across a file. As such, Ruff now represents each
+fix as a list of edits.
+
+This primarily affects the JSON API. Ruff's JSON representation used to represent the `fix` field as
+a single edit, like so:
+
+```json
+{
+    "message": "Remove unused import: `sys`",
+    "content": "",
+    "location": {"row": 1, "column": 0},
+    "end_location": {"row": 2, "column": 0}
+}
+```
+
+The updated representation instead includes a list of edits:
+
+```json
+{
+    "message": "Remove unused import: `sys`",
+    "edits": [
+        {
+            "content": "",
+            "location": {"row": 1, "column": 0},
+            "end_location": {"row": 2, "column": 0},
+        }
+    ]
+}
+```
+
 ## 0.0.246
 
 ### `multiple-statements-on-one-line-def` (`E704`) was removed ([#2773](https://github.com/charliermarsh/ruff/pull/2773))
@@ -20,8 +55,7 @@ the intention of adding a stable public API in the future.
 ### `select`, `extend-select`, `ignore`, and `extend-ignore` have new semantics ([#2312](https://github.com/charliermarsh/ruff/pull/2312))
 
 Previously, the interplay between `select` and its related options could lead to unexpected
-behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore
-ALL` behaved differently. (See [#2312](https://github.com/charliermarsh/ruff/pull/2312) for more
+behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore ALL` behaved differently. (See [#2312](https://github.com/charliermarsh/ruff/pull/2312) for more
 examples.)
 
 When Ruff determines the enabled rule set, it has to reconcile `select` and `ignore` from a variety
@@ -74,7 +108,7 @@ ruff rule E402   --format json      # Works! (And preferred.)
 This change is largely backwards compatible -- most users should experience
 no change in behavior. However, please note the following exceptions:
 
-* Subcommands will now fail when invoked with unsupported arguments, instead
+- Subcommands will now fail when invoked with unsupported arguments, instead
   of silently ignoring them. For example, the following will now fail:
 
   ```console
@@ -83,16 +117,16 @@ no change in behavior. However, please note the following exceptions:
 
   (the `clean` command doesn't support `--respect-gitignore`.)
 
-* The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
+- The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
   For example, prior to this release, running `ruff rule` would run `ruff` over a file or
   directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
   only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
   or `generate-shell-completion`.
 
-* Scripts that invoke ruff should supply `--` before any positional arguments.
+- Scripts that invoke ruff should supply `--` before any positional arguments.
   (The semantics of `ruff -- <arg>` have not changed.)
 
-* `--explain` previously treated `--format grouped` as a synonym for `--format text`.
+- `--explain` previously treated `--format grouped` as a synonym for `--format text`.
   This is no longer supported; instead, use `--format text`.
 
 ## 0.0.226
@@ -146,4 +180,4 @@ default.
 `pyproject.toml` files are now resolved hierarchically, such that for each Python file, we find
 the first `pyproject.toml` file in its path, and use that to determine its lint settings.
 
-See the [README](https://github.com/charliermarsh/ruff#pyprojecttoml-discovery) for more.
+See the [documentation](https://beta.ruff.rs/docs/configuration/#python-file-discovery) for more.

CODE_OF_CONDUCT.md

@@ -1,16 +1,16 @@
 # Contributor Covenant Code of Conduct
 
-* [Our Pledge](#our-pledge)
-* [Our Standards](#our-standards)
-* [Enforcement Responsibilities](#enforcement-responsibilities)
-* [Scope](#scope)
-* [Enforcement](#enforcement)
-* [Enforcement Guidelines](#enforcement-guidelines)
-  * [1. Correction](#1-correction)
-  * [2. Warning](#2-warning)
-  * [3. Temporary Ban](#3-temporary-ban)
-  * [4. Permanent Ban](#4-permanent-ban)
-* [Attribution](#attribution)
+- [Our Pledge](#our-pledge)
+- [Our Standards](#our-standards)
+- [Enforcement Responsibilities](#enforcement-responsibilities)
+- [Scope](#scope)
+- [Enforcement](#enforcement)
+- [Enforcement Guidelines](#enforcement-guidelines)
+  - [1. Correction](#1-correction)
+  - [2. Warning](#2-warning)
+  - [3. Temporary Ban](#3-temporary-ban)
+  - [4. Permanent Ban](#4-permanent-ban)
+- [Attribution](#attribution)
 
 ## Our Pledge
 
@@ -29,23 +29,23 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
   and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
+- Focusing on what is best not just for us as individuals, but for the
   overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
+- The use of sexualized language or imagery, and sexual attention or
   advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
   address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
+- Other conduct which could reasonably be considered inappropriate in a
   professional setting
 
 ## Enforcement Responsibilities
@@ -132,7 +132,7 @@ version 2.0, available [here](https://www.contributor-covenant.org/version/2/0/c
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
 
-[homepage]: https://www.contributor-covenant.org
-
 For answers to common questions about this code of conduct, see the [FAQ](https://www.contributor-covenant.org/faq).
 Translations are available [here](https://www.contributor-covenant.org/translations).
+
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -2,16 +2,16 @@
 
 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
-* [The Basics](#the-basics)
-  * [Prerequisites](#prerequisites)
-  * [Development](#development)
-  * [Project Structure](#project-structure)
-  * [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
-    * [Rule naming convention](#rule-naming-convention)
-  * [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
-* [MkDocs](#mkdocs)
-* [Release Process](#release-process)
-* [Benchmarks](#benchmarks)
+- [The Basics](#the-basics)
+  - [Prerequisites](#prerequisites)
+  - [Development](#development)
+  - [Project Structure](#project-structure)
+  - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
+    - [Rule naming convention](#rule-naming-convention)
+  - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+- [MkDocs](#mkdocs)
+- [Release Process](#release-process)
+- [Benchmarks](#benchmarks)
 
 ## The Basics
 
@@ -56,9 +56,9 @@ Prior to opening a pull request, ensure that your code has been auto-formatted,
 and that it passes both the lint and test validation checks:
 
 ```shell
-cargo fmt --all  # Auto-formatting...
+cargo fmt  # Auto-formatting...
 cargo clippy --fix --workspace --all-targets --all-features  # Linting...
-cargo test --all  # Testing...
+cargo test  # Testing...
 ```
 
 These checks will run on GitHub Actions when you open your Pull Request, but running them locally
@@ -91,33 +91,32 @@ The vast majority of the code, including all lint rules, lives in the `ruff` cra
 
 At time of writing, the repository includes the following crates:
 
-* `crates/ruff`: library crate containing all lint rules and the core logic for running them.
-* `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
-* `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g., `cargo dev generate-all`).
-* `crates/ruff_macros`: library crate containing macros used by Ruff.
-* `crates/ruff_python`: library crate implementing Python-specific functionality (e.g., lists of standard library modules by versionb).
-* `crates/flake8_to_ruff`: binary crate for generating Ruff configuration from Flake8 configuration.
+- `crates/ruff`: library crate containing all lint rules and the core logic for running them.
+- `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
+- `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g., `cargo dev generate-all`).
+- `crates/ruff_macros`: library crate containing macros used by Ruff.
+- `crates/ruff_python`: library crate implementing Python-specific functionality (e.g., lists of standard library modules by versionb).
+- `crates/flake8_to_ruff`: binary crate for generating Ruff configuration from Flake8 configuration.
 
 ### Example: Adding a new lint rule
 
 At a high level, the steps involved in adding a new lint rule are as follows:
 
 1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention).
-2. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
-3. In that file, define a violation struct. You can grep for `define_violation!` to see examples.
-4. Map the violation struct to a rule code in `crates/ruff/src/registry.rs` (e.g., `E402`).
-5. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast.rs` (for AST-based
+1. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
+1. In that file, define a violation struct. You can grep for `#[violation]` to see examples.
+1. Map the violation struct to a rule code in `crates/ruff/src/registry.rs` (e.g., `E402`).
+1. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast.rs` (for AST-based
    checks), `crates/ruff/src/checkers/tokens.rs` (for token-based checks), `crates/ruff/src/checkers/lines.rs`
    (for text-based checks), or `crates/ruff/src/checkers/filesystem.rs` (for filesystem-based
    checks).
-6. Add a test fixture.
-7. Update the generated files (documentation and generated code).
+1. Add a test fixture.
+1. Update the generated files (documentation and generated code).
 
 To define the violation, start by creating a dedicated file for your rule under the appropriate
 rule linter (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`). That file should
-contain a struct defined via `define_violation!`, along with a function that creates the violation
-based on any required inputs. (Many of the existing examples live in `crates/ruff/src/violations.rs`,
-but we're looking to place new rules in their own files.)
+contain a struct defined via `#[violation]`, along with a function that creates the violation
+based on any required inputs.
 
 To trigger the violation, you'll likely want to augment the logic in `crates/ruff/src/checkers/ast.rs`,
 which defines the Python AST visitor, responsible for iterating over the abstract syntax tree and
@@ -135,7 +134,7 @@ Run `cargo dev generate-all` to generate the code for your new fixture. Then run
 locally with (e.g.) `cargo run -p ruff_cli -- check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402`.
 
 Once you're satisfied with the output, codify the behavior as a snapshot test by adding a new
-`test_case` macro in the relevant `crates/ruff/src/[linter]/mod.rs` file. Then, run `cargo test --all`.
+`test_case` macro in the relevant `crates/ruff/src/[linter]/mod.rs` file. Then, run `cargo test`.
 Your test will fail, but you'll be prompted to follow-up with `cargo insta review`. Accept the
 generated snapshot, then commit the snapshot file alongside the rest of your changes.
 
@@ -147,11 +146,14 @@ The rule name should make sense when read as "allow _rule-name_" or "allow _rule
 
 This implies that rule names:
 
-* should state the bad thing being checked for
+- should state the bad thing being checked for
 
-* should not contain instructions on what you what you should use instead
+- should not contain instructions on what you what you should use instead
   (these belong in the rule documentation and the `autofix_title` for rules that have autofix)
 
+When re-implementing rules from other linters, this convention is given more importance than
+preserving the original rule name.
+
 ### Example: Adding a new configuration option
 
 Ruff's user-facing settings live in a few different places.
@@ -188,13 +190,13 @@ To preview any changes to the documentation locally:
    pip install -r docs/requirements.txt
    ```
 
-2. Generate the MkDocs site with:
+1. Generate the MkDocs site with:
 
    ```shell
    python scripts/generate_mkdocs.py
    ```
 
-3. Run the development server with:
+1. Run the development server with:
 
    ```shell
    mkdocs serve
@@ -212,6 +214,20 @@ them to [PyPI](https://pypi.org/project/ruff/).
 Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
 
+## Ecosystem CI
+
+GitHub Actions will run your changes against a number of real-world projects from GitHub and
+report on any diagnostic differences. You can also run those checks locally via:
+
+```shell
+python scripts/check_ecosystem.py path/to/your/ruff path/to/older/ruff
+```
+
+You can also run the Ecosystem CI check in a Docker container across a larger set of projects by
+downloading the [`known-github-tomls.json`](https://github.com/akx/ruff-usage-aggregate/blob/master/data/known-github-tomls.jsonl)
+as `github_search.jsonl` and following the instructions in [scripts/Dockerfile.ecosystem](scripts/Dockerfile.ecosystem).
+Note that this check will take a while to run.
+
 ## Benchmarks
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,

Cargo.toml

@@ -3,30 +3,54 @@ members = ["crates/*"]
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.65.0"
+rust-version = "1.69"
+homepage = "https://beta.ruff.rs/docs/"
+documentation = "https://beta.ruff.rs/docs/"
+repository = "https://github.com/charliermarsh/ruff"
+authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 
 [workspace.dependencies]
-anyhow = { version = "1.0.66" }
-clap = { version = "4.0.1", features = ["derive"] }
+anyhow = { version = "1.0.69" }
+bitflags = { version = "2.1.0" }
+chrono = { version = "0.4.23", default-features = false, features = ["clock"] }
+clap = { version = "4.1.8", features = ["derive"] }
+colored = { version = "2.0.0" }
+filetime = { version = "0.2.20" }
+glob = { version = "0.3.1" }
+globset = { version = "0.4.10" }
+ignore = { version = "0.4.20" }
+insta = { version = "1.28.0" }
+is-macro = { version = "0.2.2" }
 itertools = { version = "0.10.5" }
-libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
-once_cell = { version = "1.16.0" }
-regex = { version = "1.6.0" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "80e4c1399f95e5beb532fdd1e209ad2dbb470438" }
+log = { version = "0.4.17" }
+nohash-hasher = { version = "0.2.0" }
+once_cell = { version = "1.17.1" }
+path-absolutize = { version = "3.0.14" }
+proc-macro2 = { version = "1.0.51" }
+quote = { version = "1.0.23" }
+regex = { version = "1.7.1" }
 rustc-hash = { version = "1.1.0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "ddf497623ae56d21aa4166ff1c0725a7db67e955" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "ddf497623ae56d21aa4166ff1c0725a7db67e955" }
-schemars = { version = "0.8.11" }
-serde = { version = "1.0.147", features = ["derive"] }
-serde_json = { version = "1.0.87" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
+rustpython-parser = { features = [
+  "lalrpop",
+  "serde",
+], git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
+schemars = { version = "0.8.12" }
+serde = { version = "1.0.152", features = ["derive"] }
+serde_json = { version = "1.0.93", features = ["preserve_order"] }
+shellexpand = { version = "3.0.0" }
+similar = { version = "2.2.1" }
+smallvec = { version = "1.10.0" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }
-toml = { version = "0.6.0" }
+syn = { version = "2.0.15" }
+test-case = { version = "3.0.0" }
+textwrap = { version = "0.16.0" }
+toml = { version = "0.7.2" }
 
 [profile.release]
-panic = "abort"
-lto = "thin"
-codegen-units = 1
-opt-level = 3
+lto = "fat"
 
 [profile.dev.package.insta]
 opt-level = 3
@@ -38,3 +62,9 @@ opt-level = 3
 # https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wasmparser/src/limits.rs#L29
 [profile.dev.package.rustpython-parser]
 opt-level = 1
+
+# Use the `--profile release-debug` flag to show symbols in release mode.
+# e.g. `cargo build --profile release-debug`
+[profile.release-debug]
+inherits = "release"
+debug = 1

LICENSE

@@ -195,6 +195,15 @@ are:
     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   """
 
+- flake8-gettext, licensed as follows:
+  """
+    BSD Zero Clause License
+
+    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  """
+
 - flake8-implicit-str-concat, licensed as follows:
   """
     The MIT License (MIT)
@@ -393,7 +402,6 @@ are:
     THE SOFTWARE.
   """
 
-
 - autoflake, licensed as follows:
   """
     Copyright (C) 2012-2018 Steven Myint
@@ -417,6 +425,31 @@ are:
     SOFTWARE.
   """
 
+- autotyping, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2023 Jelle Zijlstra
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
 - Flake8, licensed as follows:
   """
     == Flake8 License (MIT) ==

README.md

@@ -24,17 +24,17 @@ An extremely fast Python linter, written in Rust.
   <i>Linting the CPython codebase from scratch.</i>
 </p>
 
-* ⚡️  10-100x faster than existing linters
-* 🐍  Installable via `pip`
-* 🛠️  `pyproject.toml` support
-* 🤝  Python 3.11 compatibility
-* 📦  Built-in caching, to avoid re-analyzing unchanged files
-* 🔧  Autofix support, for automatic error correction (e.g., automatically remove unused imports)
-* 📏  Over [400 built-in rules](https://beta.ruff.rs/docs/rules/) (and growing)
-* ⚖️  [Near-parity](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
-* 🔌  Native re-implementations of dozens of Flake8 plugins, like flake8-bugbear
-* ⌨️  First-party editor integrations for [VS Code](https://github.com/charliermarsh/ruff-vscode) and [more](https://github.com/charliermarsh/ruff-lsp)
-* 🌎  Monorepo-friendly, with [hierarchical and cascading configuration](#pyprojecttoml-discovery)
+- ⚡️  10-100x faster than existing linters
+- 🐍  Installable via `pip`
+- 🛠️  `pyproject.toml` support
+- 🤝  Python 3.11 compatibility
+- 📦  Built-in caching, to avoid re-analyzing unchanged files
+- 🔧  Autofix support, for automatic error correction (e.g., automatically remove unused imports)
+- 📏  Over [500 built-in rules](https://beta.ruff.rs/docs/rules/)
+- ⚖️  [Near-parity](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
+- 🔌  Native re-implementations of dozens of Flake8 plugins, like flake8-bugbear
+- ⌨️  First-party editor integrations for [VS Code](https://github.com/charliermarsh/ruff-vscode) and [more](https://github.com/charliermarsh/ruff-lsp)
+- 🌎  Monorepo-friendly, with [hierarchical and cascading configuration](https://beta.ruff.rs/docs/configuration/#pyprojecttoml-discovery)
 
 Ruff aims to be orders of magnitude faster than alternative tools while integrating more
 functionality behind a single, common interface.
@@ -47,16 +47,16 @@ all while executing tens or hundreds of times faster than any individual tool.
 
 Ruff is extremely actively developed and used in major open-source projects like:
 
-* [pandas](https://github.com/pandas-dev/pandas)
-* [FastAPI](https://github.com/tiangolo/fastapi)
-* [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
-* [Apache Airflow](https://github.com/apache/airflow)
-* [SciPy](https://github.com/scipy/scipy)
+- [Apache Airflow](https://github.com/apache/airflow)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Hugging Face](https://github.com/huggingface/transformers)
+- [Pandas](https://github.com/pandas-dev/pandas)
+- [SciPy](https://github.com/scipy/scipy)
 
 ...and many more.
 
-Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster) or
-the most recent [project update](https://notes.crmarsh.com/ruff-the-first-200-releases).
+Ruff is backed by [Astral](https://astral.sh). Read the [launch post](https://astral.sh/blog/announcing-astral-the-company-behind-ruff),
+or the original [project announcement](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
 ## Testimonials
 
@@ -97,21 +97,19 @@ developer of [Zulip](https://github.com/zulip/zulip):
 
 For more, see the [documentation](https://beta.ruff.rs/docs/).
 
-1. [Installation and Usage](#installation-and-usage)
-2. [Configuration](#configuration)
-3. [Supported Rules](#supported-rules)
-4. [Contributing](#contributing)
-5. [Support](#support)
-6. [Acknowledgements](#acknowledgements)
-7. [Who's Using Ruff?](#whos-using-ruff)
-8. [License](#license)
+1. [Getting Started](#getting-started)
+1. [Configuration](#configuration)
+1. [Rules](#rules)
+1. [Contributing](#contributing)
+1. [Support](#support)
+1. [Acknowledgements](#acknowledgements)
+1. [Who's Using Ruff?](#whos-using-ruff)
+1. [License](#license)
 
-## Installation and Usage
+## Getting Started
 
 For more, see the [documentation](https://beta.ruff.rs/docs/).
 
-<!-- Begin section: Installation and Usage -->
-
 ### Installation
 
 Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
@@ -120,31 +118,8 @@ Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 pip install ruff
 ```
 
-For **macOS Homebrew** and **Linuxbrew** users, Ruff is also available as [`ruff`](https://formulae.brew.sh/formula/ruff) on Homebrew:
-
-```shell
-brew install ruff
-```
-
-For **Conda** users, Ruff is also available as [`ruff`](https://anaconda.org/conda-forge/ruff) on `conda-forge`:
-
-```shell
-conda install -c conda-forge ruff
-```
-
-For **Arch Linux** users, Ruff is also available as [`ruff`](https://archlinux.org/packages/community/x86_64/ruff/) on the official repositories:
-
-```shell
-pacman -S ruff
-```
-
-For **Alpine** users, Ruff is also available as [`ruff`](https://pkgs.alpinelinux.org/package/edge/testing/x86_64/ruff) on the testing repositories:
-
-```shell
-apk add ruff
-```
-
-[![Packaging status](https://repology.org/badge/vertical-allrepos/ruff-python-linter.svg?exclude_unsupported=1)](https://repology.org/project/ruff-python-linter/versions)
+You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
+and with [a variety of other package managers](https://beta.ruff.rs/docs/installation/).
 
 ### Usage
 
@@ -157,56 +132,49 @@ ruff check path/to/code/*.py        # Lint all `.py` files in `/path/to/code`
 ruff check path/to/code/to/file.py  # Lint `file.py`
 ```
 
-You can run Ruff in `--watch` mode to automatically re-run on-change:
-
-```shell
-ruff check path/to/code/ --watch
-```
-
-Ruff also works with [pre-commit](https://pre-commit.com):
+Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 
 ```yaml
 - repo: https://github.com/charliermarsh/ruff-pre-commit
   # Ruff version.
-  rev: 'v0.0.250'
+  rev: 'v0.0.263'
   hooks:
     - id: ruff
 ```
 
-Or, to enable autofix:
+Ruff can also be used as a [VS Code extension](https://github.com/charliermarsh/ruff-vscode) or
+alongside any other editor through the [Ruff LSP](https://github.com/charliermarsh/ruff-lsp).
+
+Ruff can also be used as a [GitHub Action](https://github.com/features/actions) via
+[`ruff-action`](https://github.com/chartboost/ruff-action):
 
 ```yaml
-- repo: https://github.com/charliermarsh/ruff-pre-commit
-  # Ruff version.
-  rev: 'v0.0.250'
-  hooks:
-    - id: ruff
-      args: [--fix, --exit-non-zero-on-fix]
+name: Ruff
+on: [ push, pull_request ]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: chartboost/ruff-action@v1
 ```
 
-<!-- End section: Installation and Usage -->
+### Configuration
 
-## Configuration
-
-<!-- Begin section: Configuration -->
-
-Ruff can be configured via a `pyproject.toml` file, a `ruff.toml` file, or through the command line.
-
-For a complete enumeration of the available configuration options, see the
-[documentation](https://beta.ruff.rs/docs/settings/).
-
-### Configure via `pyproject.toml`
+Ruff can be configured through a `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file (see:
+[_Configuration_](https://beta.ruff.rs/docs/configuration/), or [_Settings_](https://beta.ruff.rs/docs/settings/)
+for a complete list of all configuration options).
 
 If left unspecified, the default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
-# Enable Pyflakes `E` and `F` codes by default.
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
 select = ["E", "F"]
 ignore = []
 
 # Allow autofix for all enabled rules (when `--fix`) is provided.
-fixable = ["A", "B", "C", "D", "E", "F", "..."]
+fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
 unfixable = []
 
 # Exclude a variety of commonly ignored directories.
@@ -232,7 +200,6 @@ exclude = [
     "node_modules",
     "venv",
 ]
-per-file-ignores = {}
 
 # Same as Black.
 line-length = 88
@@ -248,428 +215,91 @@ target-version = "py310"
 max-complexity = 10
 ```
 
-As an example, the following would configure Ruff to: (1) enforce flake8-bugbear rules, in addition
-to the defaults; (2) avoid enforcing line-length violations (`E501`); (3) avoid attempting to fix
-flake8-bugbear (`B`) violations; and (3) ignore import-at-top-of-file violations (`E402`) in
-`__init__.py` files:
-
-```toml
-[tool.ruff]
-# Enable flake8-bugbear (`B`) rules.
-select = ["E", "F", "B"]
-
-# Never enforce `E501` (line length violations).
-ignore = ["E501"]
-
-# Avoid trying to fix flake8-bugbear (`B`) violations.
-unfixable = ["B"]
-
-# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
-[tool.ruff.per-file-ignores]
-"__init__.py" = ["E402"]
-"path/to/file.py" = ["E402"]
-```
-
-Plugin configurations should be expressed as subsections, e.g.:
-
-```toml
-[tool.ruff]
-# Add "Q" to the list of enabled codes.
-select = ["E", "F", "Q"]
-
-[tool.ruff.flake8-quotes]
-docstring-quotes = "double"
-```
-
-Ruff mirrors Flake8's rule code system, in which each rule code consists of a one-to-three letter
-prefix, followed by three digits (e.g., `F401`). The prefix indicates that "source" of the rule
-(e.g., `F` for Pyflakes, `E` for pycodestyle, `ANN` for flake8-annotations). The set of enabled
-rules is determined by the `select` and `ignore` options, which support both the full code (e.g.,
-`F401`) and the prefix (e.g., `F`).
-
-As a special-case, Ruff also supports the `ALL` code, which enables all rules. Note that some of the
-pydocstyle rules conflict (e.g., `D203` and `D211`) as they represent alternative docstring
-formats. Enabling `ALL` without further configuration may result in suboptimal behavior, especially
-for the pydocstyle plugin.
-
-If you're wondering how to configure Ruff, here are some **recommended guidelines**:
-
-* Prefer `select` and `ignore` over `extend-select` and `extend-ignore`, to make your rule set
-  explicit.
-* Use `ALL` with discretion. Enabling `ALL` will implicitly enable new rules whenever you upgrade.
-* Start with a small set of rules (`select = ["E", "F"]`) and add a category at-a-time. For example,
-  you might consider expanding to `select = ["E", "F", "B"]` to enable the popular flake8-bugbear
-  extension.
-* By default, Ruff's autofix is aggressive. If you find that it's too aggressive for your liking,
-  consider turning off autofix for specific rules or categories (see: [FAQ](https://beta.ruff.rs/docs/faq/#ruff-tried-to-fix-something-but-it-broke-my-code-what-should-i-do)).
-
-### Configure via `ruff.toml`
-
-As an alternative to `pyproject.toml`, Ruff will also respect a `ruff.toml` file, which implements
-an equivalent schema (though the `[tool.ruff]` hierarchy can be omitted). For example, the
-`pyproject.toml` described above would be represented via the following `ruff.toml`:
-
-```toml
-# Enable flake8-bugbear (`B`) rules.
-select = ["E", "F", "B"]
-
-# Never enforce `E501` (line length violations).
-ignore = ["E501"]
-
-# Avoid trying to fix flake8-bugbear (`B`) violations.
-unfixable = ["B"]
-
-# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
-[per-file-ignores]
-"__init__.py" = ["E402"]
-"path/to/file.py" = ["E402"]
-```
-
-For a full list of configurable options, see the [list of all options](https://beta.ruff.rs/docs/settings/).
-
-### Command-line interface
-
-Some configuration settings can be provided via the command-line, such as those related to
+Some configuration options can be provided via the command-line, such as those related to
 rule enablement and disablement, file discovery, logging level, and more:
 
 ```shell
 ruff check path/to/code/ --select F401 --select F403 --quiet
 ```
 
-See `ruff help` for more on Ruff's top-level commands:
+See `ruff help` for more on Ruff's top-level commands, or `ruff help check` for more on the
+linting command.
 
-<!-- Begin auto-generated command help. -->
-
-```text
-Ruff: An extremely fast Python linter.
-
-Usage: ruff [OPTIONS] <COMMAND>
-
-Commands:
-  check   Run Ruff on the given files or directories (default)
-  rule    Explain a rule
-  config  List or describe the available configuration options
-  linter  List all supported upstream linters
-  clean   Clear any caches in the current directory and any subdirectories
-  help    Print this message or the help of the given subcommand(s)
-
-Options:
-  -h, --help     Print help
-  -V, --version  Print version
-
-Log levels:
-  -v, --verbose  Enable verbose logging
-  -q, --quiet    Print lint violations, but nothing else
-  -s, --silent   Disable all logging (but still exit with status code "1" upon detecting lint violations)
-
-For help with a specific command, see: `ruff help <command>`.
-```
-
-<!-- End auto-generated command help. -->
-
-Or `ruff help check` for more on the linting command:
-
-<!-- Begin auto-generated subcommand help. -->
-
-```text
-Run Ruff on the given files or directories (default)
-
-Usage: ruff check [OPTIONS] [FILES]...
-
-Arguments:
-  [FILES]...  List of files or directories to check
-
-Options:
-      --fix
-          Attempt to automatically fix lint violations
-      --show-source
-          Show violations with source code
-      --show-fixes
-          Show an enumeration of all autofixed lint violations
-      --diff
-          Avoid writing any fixed files back; instead, output a diff for each changed file to stdout
-  -w, --watch
-          Run in watch mode by re-running whenever files change
-      --fix-only
-          Fix any fixable lint violations, but don't report on leftover violations. Implies `--fix`
-      --format <FORMAT>
-          Output serialization format for violations [env: RUFF_FORMAT=] [possible values: text, json, junit, grouped, github, gitlab, pylint]
-      --target-version <TARGET_VERSION>
-          The minimum Python version that should be supported
-      --config <CONFIG>
-          Path to the `pyproject.toml` or `ruff.toml` file to use for configuration
-      --statistics
-          Show counts for every rule with at least one violation
-      --add-noqa
-          Enable automatic additions of `noqa` directives to failing lines
-      --show-files
-          See the files Ruff will be run against with the current settings
-      --show-settings
-          See the settings Ruff will use to lint a given Python file
-  -h, --help
-          Print help
-
-Rule selection:
-      --select <RULE_CODE>
-          Comma-separated list of rule codes to enable (or ALL, to enable all rules)
-      --ignore <RULE_CODE>
-          Comma-separated list of rule codes to disable
-      --extend-select <RULE_CODE>
-          Like --select, but adds additional rule codes on top of the selected ones
-      --per-file-ignores <PER_FILE_IGNORES>
-          List of mappings from file pattern to code to exclude
-      --fixable <RULE_CODE>
-          List of rule codes to treat as eligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
-      --unfixable <RULE_CODE>
-          List of rule codes to treat as ineligible for autofix. Only applicable when autofix itself is enabled (e.g., via `--fix`)
-
-File selection:
-      --exclude <FILE_PATTERN>         List of paths, used to omit files and/or directories from analysis
-      --extend-exclude <FILE_PATTERN>  Like --exclude, but adds additional files and directories on top of those already excluded
-      --respect-gitignore              Respect file exclusions via `.gitignore` and other standard ignore files
-      --force-exclude                  Enforce exclusions, even for paths passed to Ruff directly on the command-line
-
-Miscellaneous:
-  -n, --no-cache
-          Disable cache reads
-      --isolated
-          Ignore all configuration files
-      --cache-dir <CACHE_DIR>
-          Path to the cache directory [env: RUFF_CACHE_DIR=]
-      --stdin-filename <STDIN_FILENAME>
-          The name of the file when passing it through stdin
-  -e, --exit-zero
-          Exit with status code "0", even upon detecting lint violations
-      --exit-non-zero-on-fix
-          Exit with a non-zero status code if any files were modified via autofix, even if no lint violations remain
-
-Log levels:
-  -v, --verbose  Enable verbose logging
-  -q, --quiet    Print lint violations, but nothing else
-  -s, --silent   Disable all logging (but still exit with status code "1" upon detecting lint violations)
-```
-
-<!-- End auto-generated subcommand help. -->
-
-### `pyproject.toml` discovery
-
-Similar to [ESLint](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#cascading-and-hierarchy),
-Ruff supports hierarchical configuration, such that the "closest" `pyproject.toml` file in the
-directory hierarchy is used for every individual file, with all paths in the `pyproject.toml` file
-(e.g., `exclude` globs, `src` paths) being resolved relative to the directory containing the
-`pyproject.toml` file.
-
-There are a few exceptions to these rules:
-
-1. In locating the "closest" `pyproject.toml` file for a given path, Ruff ignores any
-   `pyproject.toml` files that lack a `[tool.ruff]` section.
-2. If a configuration file is passed directly via `--config`, those settings are used for across
-   files. Any relative paths in that configuration file (like `exclude` globs or `src` paths) are
-   resolved relative to the _current working directory_.
-3. If no `pyproject.toml` file is found in the filesystem hierarchy, Ruff will fall back to using
-   a default configuration. If a user-specific configuration file exists
-   at `${config_dir}/ruff/pyproject.toml`, that file will be used instead of the default
-   configuration, with `${config_dir}` being determined via the [`dirs`](https://docs.rs/dirs/4.0.0/dirs/fn.config_dir.html)
-   crate, and all relative paths being again resolved relative to the _current working directory_.
-4. Any `pyproject.toml`-supported settings that are provided on the command-line (e.g., via
-   `--select`) will override the settings in _every_ resolved configuration file.
-
-Unlike [ESLint](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#cascading-and-hierarchy),
-Ruff does not merge settings across configuration files; instead, the "closest" configuration file
-is used, and any parent configuration files are ignored. In lieu of this implicit cascade, Ruff
-supports an [`extend`](https://beta.ruff.rs/docs/settings#extend) field, which allows you to inherit the settings from another
-`pyproject.toml` file, like so:
-
-```toml
-# Extend the `pyproject.toml` file in the parent directory.
-extend = "../pyproject.toml"
-# But use a different line length.
-line-length = 100
-```
-
-All of the above rules apply equivalently to `ruff.toml` files. If Ruff detects both a `ruff.toml`
-and `pyproject.toml` file, it will defer to the `ruff.toml`.
-
-### Python file discovery
-
-When passed a path on the command-line, Ruff will automatically discover all Python files in that
-path, taking into account the [`exclude`](https://beta.ruff.rs/docs/settings#exclude) and
-[`extend-exclude`](https://beta.ruff.rs/docs/settings#extend-exclude) settings in each directory's
-`pyproject.toml` file.
-
-By default, Ruff will also skip any files that are omitted via `.ignore`, `.gitignore`,
-`.git/info/exclude`, and global `gitignore` files (see: [`respect-gitignore`](https://beta.ruff.rs/docs/settings#respect-gitignore)).
-
-Files that are passed to `ruff` directly are always linted, regardless of the above criteria.
-For example, `ruff check /path/to/excluded/file.py` will always lint `file.py`.
-
-### Rule resolution
-
-The set of enabled rules is controlled via the [`select`](https://beta.ruff.rs/docs/settings#select)
-and [`ignore`](https://beta.ruff.rs/docs/settings#ignore) settings, along with the
-[`extend-select`](https://beta.ruff.rs/docs/settings#extend-select) and
-[`extend-ignore`](https://beta.ruff.rs/docs/settings#extend-ignore) modifiers.
-
-To resolve the enabled rule set, Ruff may need to reconcile `select` and `ignore` from a variety
-of sources, including the current `pyproject.toml`, any inherited `pyproject.toml` files, and the
-CLI (e.g., `--select`).
-
-In those scenarios, Ruff uses the "highest-priority" `select` as the basis for the rule set, and
-then applies any `extend-select`, `ignore`, and `extend-ignore` adjustments. CLI options are given
-higher priority than `pyproject.toml` options, and the current `pyproject.toml` file is given higher
-priority than any inherited `pyproject.toml` files.
-
-For example, given the following `pyproject.toml` file:
-
-```toml
-[tool.ruff]
-select = ["E", "F"]
-ignore = ["F401"]
-```
-
-Running `ruff check --select F401` would result in Ruff enforcing `F401`, and no other rules.
-
-Running `ruff check --extend-select B` would result in Ruff enforcing the `E`, `F`, and `B` rules, with
-the exception of `F401`.
-
-### Suppressing errors
-
-To omit a lint rule entirely, add it to the "ignore" list via [`ignore`](https://beta.ruff.rs/docs/settings#ignore)
-or [`extend-ignore`](https://beta.ruff.rs/docs/settings#extend-ignore), either on the command-line
-or in your `pyproject.toml` file.
-
-To ignore a violation inline, Ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
-To ignore an individual violation, add `# noqa: {code}` to the end of the line, like so:
-
-```python
-# Ignore F841.
-x = 1  # noqa: F841
-
-# Ignore E741 and F841.
-i = 1  # noqa: E741, F841
-
-# Ignore _all_ violations.
-x = 1  # noqa
-```
-
-Note that, for multi-line strings, the `noqa` directive should come at the end of the string, and
-will apply to the entire string, like so:
-
-```python
-"""Lorem ipsum dolor sit amet.
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.
-"""  # noqa: E501
-```
-
-To ignore all violations across an entire file, add `# ruff: noqa` to any line in the file, like so:
-
-```python
-# ruff: noqa
-```
-
-To ignore a specific rule across an entire file, add `# ruff: noqa: {code}` to any line in the file,
-like so:
-
-```python
-# ruff: noqa: F841
-```
-
-Or see the [`per-file-ignores`](https://beta.ruff.rs/docs/settings#per-file-ignores) configuration
-setting, which enables the same functionality via a `pyproject.toml` file.
-
-Note that Ruff will also respect Flake8's `# flake8: noqa` directive, and will treat it as
-equivalent to `# ruff: noqa`.
-
-#### Automatic error suppression
-
-Ruff supports several workflows to aid in `noqa` management.
-
-First, Ruff provides a special rule code, `RUF100`, to enforce that your `noqa` directives are
-"valid", in that the violations they _say_ they ignore are actually being triggered on that line (and
-thus suppressed). You can run `ruff check /path/to/file.py --extend-select RUF100` to flag unused `noqa`
-directives.
-
-Second, Ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
-You can run `ruff check /path/to/file.py --extend-select RUF100 --fix` to automatically remove unused
-`noqa` directives.
-
-Third, Ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
-migrating a new codebase to Ruff. You can run `ruff check /path/to/file.py --add-noqa` to automatically
-add `noqa` directives to all failing lines, with the appropriate rule codes.
-
-#### Action comments
-
-Ruff respects `isort`'s [action comments](https://pycqa.github.io/isort/docs/configuration/action_comments.html)
-(`# isort: skip_file`, `# isort: on`, `# isort: off`, `# isort: skip`, and `# isort: split`), which
-enable selectively enabling and disabling import sorting for blocks of code and other inline
-configuration.
-
-See the [`isort` documentation](https://pycqa.github.io/isort/docs/configuration/action_comments.html)
-for more.
-
-### Exit codes
-
-By default, Ruff exits with the following status codes:
-
-* `0` if no violations were found, or if all present violations were fixed automatically.
-* `1` if violations were found.
-* `2` if Ruff terminates abnormally due to invalid configuration, invalid CLI options, or an internal error.
-
-This convention mirrors that of tools like ESLint, Prettier, and RuboCop.
-
-Ruff supports two command-line flags that alter its exit code behavior:
-
-* `--exit-zero` will cause Ruff to exit with a status code of `0` even if violations were found.
-  Note that Ruff will still exit with a status code of `2` if it terminates abnormally.
-* `--exit-non-zero-on-fix` will cause Ruff to exit with a status code of `1` if violations were
-  found, _even if_ all such violations were fixed automatically. Note that the use of
-  `--exit-non-zero-on-fix` can result in a non-zero exit code even if no violations remain after
-  autofixing.
-
-### Autocompletion
-
-Ruff supports autocompletion for most shells. A shell-specific completion script can be generated
-by `ruff generate-shell-completion <SHELL>`, where `<SHELL>` is one of `bash`, `elvish`, `fig`, `fish`,
-`powershell`, or `zsh`.
-
-The exact steps required to enable autocompletion will vary by shell. For example instructions,
-see the [Poetry](https://python-poetry.org/docs/#enable-tab-completion-for-bash-fish-or-zsh) or
-[ripgrep](https://github.com/BurntSushi/ripgrep/blob/master/FAQ.md#complete) documentation.
-
-As an example: to enable autocompletion for Zsh, run
-`ruff generate-shell-completion zsh > ~/.zfunc/_ruff`. Then add the following line to your
-`~/.zshrc` file, if they're not already present:
-
-```zsh
-fpath+=~/.zfunc
-autoload -Uz compinit && compinit
-```
-
-<!-- End section: Configuration -->
-
-## Supported Rules
+## Rules
 
 <!-- Begin section: Rules -->
 
-Ruff supports over 400 lint rules, many of which are inspired by popular tools like Flake8, isort,
-pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in
+**Ruff supports over 500 lint rules**, many of which are inspired by popular tools like Flake8,
+isort, pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in
 Rust as a first-party feature.
 
 By default, Ruff enables Flake8's `E` and `F` rules. Ruff supports all rules from the `F` category,
 and a [subset](https://beta.ruff.rs/docs/rules/#error-e) of the `E` category, omitting those
-stylistic rules made obsolete by the use of an autoformatter, like [Black](https://github.com/psf/black).
+stylistic rules made obsolete by the use of an autoformatter, like
+[Black](https://github.com/psf/black).
+
+If you're just getting started with Ruff, **the default rule set is a great place to start**: it
+catches a wide variety of common errors (like unused imports) with zero configuration.
+
+Beyond the defaults, Ruff re-implements some of the most popular Flake8 plugins and related code
+quality tools, including:
+
+- [autoflake](https://pypi.org/project/autoflake/)
+- [eradicate](https://pypi.org/project/eradicate/)
+- [flake8-2020](https://pypi.org/project/flake8-2020/)
+- [flake8-annotations](https://pypi.org/project/flake8-annotations/)
+- [flake8-bandit](https://pypi.org/project/flake8-bandit/) ([#1646](https://github.com/charliermarsh/ruff/issues/1646))
+- [flake8-blind-except](https://pypi.org/project/flake8-blind-except/)
+- [flake8-boolean-trap](https://pypi.org/project/flake8-boolean-trap/)
+- [flake8-bugbear](https://pypi.org/project/flake8-bugbear/)
+- [flake8-builtins](https://pypi.org/project/flake8-builtins/)
+- [flake8-commas](https://pypi.org/project/flake8-commas/)
+- [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/)
+- [flake8-datetimez](https://pypi.org/project/flake8-datetimez/)
+- [flake8-debugger](https://pypi.org/project/flake8-debugger/)
+- [flake8-django](https://pypi.org/project/flake8-django/)
+- [flake8-docstrings](https://pypi.org/project/flake8-docstrings/)
+- [flake8-eradicate](https://pypi.org/project/flake8-eradicate/)
+- [flake8-errmsg](https://pypi.org/project/flake8-errmsg/)
+- [flake8-executable](https://pypi.org/project/flake8-executable/)
+- [flake8-gettext](https://pypi.org/project/flake8-gettext/)
+- [flake8-implicit-str-concat](https://pypi.org/project/flake8-implicit-str-concat/)
+- [flake8-import-conventions](https://github.com/joaopalmeiro/flake8-import-conventions)
+- [flake8-logging-format](https://pypi.org/project/flake8-logging-format/)
+- [flake8-no-pep420](https://pypi.org/project/flake8-no-pep420)
+- [flake8-pie](https://pypi.org/project/flake8-pie/)
+- [flake8-print](https://pypi.org/project/flake8-print/)
+- [flake8-pyi](https://pypi.org/project/flake8-pyi/)
+- [flake8-pytest-style](https://pypi.org/project/flake8-pytest-style/)
+- [flake8-quotes](https://pypi.org/project/flake8-quotes/)
+- [flake8-raise](https://pypi.org/project/flake8-raise/)
+- [flake8-return](https://pypi.org/project/flake8-return/)
+- [flake8-self](https://pypi.org/project/flake8-self/)
+- [flake8-simplify](https://pypi.org/project/flake8-simplify/)
+- [flake8-super](https://pypi.org/project/flake8-super/)
+- [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/)
+- [flake8-type-checking](https://pypi.org/project/flake8-type-checking/)
+- [flake8-use-pathlib](https://pypi.org/project/flake8-use-pathlib/)
+- [isort](https://pypi.org/project/isort/)
+- [mccabe](https://pypi.org/project/mccabe/)
+- [pandas-vet](https://pypi.org/project/pandas-vet/)
+- [pep8-naming](https://pypi.org/project/pep8-naming/)
+- [pydocstyle](https://pypi.org/project/pydocstyle/)
+- [pygrep-hooks](https://github.com/pre-commit/pygrep-hooks) ([#980](https://github.com/charliermarsh/ruff/issues/980))
+- [pyupgrade](https://pypi.org/project/pyupgrade/)
+- [tryceratops](https://pypi.org/project/tryceratops/)
+- [yesqa](https://pypi.org/project/yesqa/)
 
 <!-- End section: Rules -->
 
-For a complete enumeration, see the [list of rules](https://beta.ruff.rs/docs/rules/) in the
-Ruff documentation.
+For a complete enumeration of the supported rules, see [_Rules_](https://beta.ruff.rs/docs/rules/).
 
 ## Contributing
 
 Contributions are welcome and highly appreciated. To get started, check out the
-[**contributing guidelines**](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTING.md). You
-can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5).
+[**contributing guidelines**](https://beta.ruff.rs/docs/contributing/).
+
+You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5).
 
 ## Support
 
@@ -678,8 +308,6 @@ or feel free to [**open a new one**](https://github.com/charliermarsh/ruff/issue
 
 You can also ask for help on [**Discord**](https://discord.gg/c9MhzV8aU5).
 
-<!-- Begin section: Acknowledgements -->
-
 ## Acknowledgements
 
 Ruff's linter draws on both the APIs and implementation details of many other
@@ -702,46 +330,70 @@ Ruff is the beneficiary of a large number of [contributors](https://github.com/c
 
 Ruff is released under the MIT license.
 
-<!-- End section: Acknowledgements -->
-
 ## Who's Using Ruff?
 
-Ruff is used in a number of major open-source projects, including:
+Ruff is used by a number of major open-source projects and companies, including:
 
-* [pandas](https://github.com/pandas-dev/pandas)
-* [FastAPI](https://github.com/tiangolo/fastapi)
-* [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
-* [Diffusers (Hugging Face)](https://github.com/huggingface/diffusers)
-* [Apache Airflow](https://github.com/apache/airflow)
-* [SciPy](https://github.com/scipy/scipy)
-* [Zulip](https://github.com/zulip/zulip)
-* [Bokeh](https://github.com/bokeh/bokeh)
-* [Pydantic](https://github.com/pydantic/pydantic)
-* [Dagster](https://github.com/dagster-io/dagster)
-* [Dagger](https://github.com/dagger/dagger)
-* [Sphinx](https://github.com/sphinx-doc/sphinx)
-* [Hatch](https://github.com/pypa/hatch)
-* [PDM](https://github.com/pdm-project/pdm)
-* [Jupyter](https://github.com/jupyter-server/jupyter_server)
-* [Great Expectations](https://github.com/great-expectations/great_expectations)
-* [ONNX](https://github.com/onnx/onnx)
-* [Polars](https://github.com/pola-rs/polars)
-* [Ibis](https://github.com/ibis-project/ibis)
-* [Synapse (Matrix)](https://github.com/matrix-org/synapse)
-* [SnowCLI (Snowflake)](https://github.com/Snowflake-Labs/snowcli)
-* [Dispatch (Netflix)](https://github.com/Netflix/dispatch)
-* [Saleor](https://github.com/saleor/saleor)
-* [Pynecone](https://github.com/pynecone-io/pynecone)
-* [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
-* [Home Assistant](https://github.com/home-assistant/core)
-* [Pylint](https://github.com/PyCQA/pylint)
-* [Cryptography (PyCA)](https://github.com/pyca/cryptography)
-* [cibuildwheel (PyPA)](https://github.com/pypa/cibuildwheel)
-* [build (PyPA)](https://github.com/pypa/build)
-* [Babel](https://github.com/python-babel/babel)
-* [featuretools](https://github.com/alteryx/featuretools)
-* [meson-python](https://github.com/mesonbuild/meson-python)
-* [ZenML](https://github.com/zenml-io/zenml)
+- Amazon ([AWS SAM](https://github.com/aws/serverless-application-model))
+- [Apache Airflow](https://github.com/apache/airflow)
+- AstraZeneca ([Magnus](https://github.com/AstraZeneca/magnus-core))
+- Benchling ([Refac](https://github.com/benchling/refac))
+- [Babel](https://github.com/python-babel/babel)
+- [Bokeh](https://github.com/bokeh/bokeh)
+- [Cryptography (PyCA)](https://github.com/pyca/cryptography)
+- [Dagger](https://github.com/dagger/dagger)
+- [Dagster](https://github.com/dagster-io/dagster)
+- [DVC](https://github.com/iterative/dvc)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Gradio](https://github.com/gradio-app/gradio)
+- [Great Expectations](https://github.com/great-expectations/great_expectations)
+- Hugging Face ([Transformers](https://github.com/huggingface/transformers), [Datasets](https://github.com/huggingface/datasets), [Diffusers](https://github.com/huggingface/diffusers))
+- [Hatch](https://github.com/pypa/hatch)
+- [Home Assistant](https://github.com/home-assistant/core)
+- [Ibis](https://github.com/ibis-project/ibis)
+- [Jupyter](https://github.com/jupyter-server/jupyter_server)
+- [LangChain](https://github.com/hwchase17/langchain)
+- [LlamaIndex](https://github.com/jerryjliu/llama_index)
+- Matrix ([Synapse](https://github.com/matrix-org/synapse))
+- Meltano ([Meltano CLI](https://github.com/meltano/meltano), [Singer SDK](https://github.com/meltano/sdk))
+- Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python-sdk))
+- Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
+- [MegaLinter](https://github.com/oxsecurity/megalinter)
+- Microsoft ([Semantic Kernel](https://github.com/microsoft/semantic-kernel), [ONNX Runtime](https://github.com/microsoft/onnxruntime))
+- Netflix ([Dispatch](https://github.com/Netflix/dispatch))
+- [Neon](https://github.com/neondatabase/neon)
+- [ONNX](https://github.com/onnx/onnx)
+- [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
+- [PDM](https://github.com/pdm-project/pdm)
+- [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
+- [Pandas](https://github.com/pandas-dev/pandas)
+- [Poetry](https://github.com/python-poetry/poetry)
+- [Polars](https://github.com/pola-rs/polars)
+- [PostHog](https://github.com/PostHog/posthog)
+- Prefect ([Python SDK](https://github.com/PrefectHQ/prefect), [Marvin](https://github.com/PrefectHQ/marvin))
+- [Pydantic](https://github.com/pydantic/pydantic)
+- [PyInstaller](https://github.com/pyinstaller/pyinstaller)
+- [Pylint](https://github.com/PyCQA/pylint)
+- [Pynecone](https://github.com/pynecone-io/pynecone)
+- [Robyn](https://github.com/sansyrox/robyn)
+- Scale AI ([Launch SDK](https://github.com/scaleapi/launch-python-client))
+- Snowflake ([SnowCLI](https://github.com/Snowflake-Labs/snowcli))
+- [Saleor](https://github.com/saleor/saleor)
+- [SciPy](https://github.com/scipy/scipy)
+- [Sphinx](https://github.com/sphinx-doc/sphinx)
+- [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
+- [Starlite](https://github.com/starlite-api/starlite)
+- [The Algorithms](https://github.com/TheAlgorithms/Python)
+- [Vega-Altair](https://github.com/altair-viz/altair)
+- WordPress ([Openverse](https://github.com/WordPress/openverse))
+- [ZenML](https://github.com/zenml-io/zenml)
+- [Zulip](https://github.com/zulip/zulip)
+- [build (PyPA)](https://github.com/pypa/build)
+- [cibuildwheel (PyPA)](https://github.com/pypa/cibuildwheel)
+- [delta-rs](https://github.com/delta-io/delta-rs)
+- [featuretools](https://github.com/alteryx/featuretools)
+- [meson-python](https://github.com/mesonbuild/meson-python)
+- [nox](https://github.com/wntrblm/nox)
 
 ## License
 

_typos.toml

@@ -5,3 +5,4 @@ extend-exclude = ["snapshots", "black"]
 trivias = "trivias"
 hel = "hel"
 whos = "whos"
+spawnve = "spawnve"

crates/flake8_to_ruff/Cargo.toml

@@ -1,17 +1,18 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.250"
+version = "0.0.263"
 edition = { workspace = true }
 rust-version = { workspace = true }
 
 [dependencies]
+ruff = { path = "../ruff", default-features = false }
+
 anyhow = { workspace = true }
 clap = { workspace = true }
-colored = { version = "2.0.0" }
+colored = { workspace = true }
 configparser = { version = "3.0.2" }
 once_cell = { workspace = true }
 regex = { workspace = true }
-ruff = { path = "../ruff", default-features = false }
 rustc-hash = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/flake8_to_ruff/README.md

@@ -84,9 +84,10 @@ flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
 1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
    ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
    configuration options that don't exist in Flake8.)
-2. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
-   codes from unsupported plugins. (See the [Ruff README](https://github.com/charliermarsh/ruff#user-content-how-does-ruff-compare-to-flake8)
-   for the complete list of supported plugins.)
+1. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
+   codes from unsupported plugins. (See the
+   [documentation](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) for the complete
+   list of supported plugins.)
 
 ## License
 

crates/flake8_to_ruff/src/main.rs

@@ -46,8 +46,15 @@ fn main() -> Result<()> {
         .map(|tool| ExternalConfig {
             black: tool.black.as_ref(),
             isort: tool.isort.as_ref(),
+            ..Default::default()
         })
         .unwrap_or_default();
+    let external_config = ExternalConfig {
+        project: pyproject
+            .as_ref()
+            .and_then(|pyproject| pyproject.project.as_ref()),
+        ..external_config
+    };
 
     // Create Ruff's pyproject.toml section.
     let pyproject = flake8_to_ruff::convert(&config, &external_config, args.plugin)?;

crates/ruff/Cargo.toml

@@ -1,82 +1,84 @@
 [package]
 name = "ruff"
-version = "0.0.250"
-authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
-edition = { workspace = true }
-rust-version = { workspace = true }
-documentation = "https://github.com/charliermarsh/ruff"
-homepage = "https://github.com/charliermarsh/ruff"
-repository = "https://github.com/charliermarsh/ruff"
+version = "0.0.263"
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+documentation.workspace = true
+homepage.workspace = true
+repository.workspace = true
 readme = "README.md"
 license = "MIT"
 
 [lib]
 name = "ruff"
-crate-type = ["cdylib", "rlib"]
-doctest = false
 
 [dependencies]
+ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
+ruff_macros = { path = "../ruff_macros" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_semantic = { path = "../ruff_python_semantic" }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+ruff_rustpython = { path = "../ruff_rustpython" }
+ruff_text_size = { path = "../ruff_text_size" }
+
+annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { workspace = true }
-bisection = { version = "0.1.0" }
-bitflags = { version = "1.3.2" }
-cfg-if = { version = "1.0.0" }
-chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
-clap = { workspace = true, features = ["derive", "env", "string"] }
-colored = { version = "2.0.0" }
-dirs = { version = "4.0.0" }
+bitflags = { workspace = true }
+chrono = { workspace = true }
+clap = { workspace = true, features = ["derive", "string"], optional = true }
+colored = { workspace = true }
+dirs = { version = "5.0.0" }
 fern = { version = "0.6.1" }
-glob = { version = "0.3.0" }
-globset = { version = "0.4.9" }
-ignore = { version = "0.4.18" }
-imperative = { version = "1.0.3" }
+glob = { workspace = true }
+globset = { workspace = true }
+ignore = { workspace = true }
+imperative = { version = "1.0.4" }
+is-macro = { workspace = true }
 itertools = { workspace = true }
 libcst = { workspace = true }
-log = { version = "0.4.17" }
+log = { workspace = true }
 natord = { version = "1.0.9" }
-nohash-hasher = { version = "0.2.0" }
+nohash-hasher = { workspace = true }
 num-bigint = { version = "0.4.3" }
-num-traits = "0.2.15"
+num-traits = { version = "0.2.15" }
 once_cell = { workspace = true }
-path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
+path-absolutize = { workspace = true, features = [
+  "once_cell_cache",
+  "use_unix_paths_on_wasm",
+] }
+pathdiff = { version = "0.2.1" }
+pep440_rs = { version = "0.3.1", features = ["serde"] }
+quick-junit = { version = "0.3.2" }
 regex = { workspace = true }
-ruff_macros = { path = "../ruff_macros" }
-ruff_python = { path = "../ruff_python" }
+result-like = { version = "0.4.6" }
 rustc-hash = { workspace = true }
 rustpython-common = { workspace = true }
 rustpython-parser = { workspace = true }
 schemars = { workspace = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }
-shellexpand = { version = "3.0.0" }
-smallvec = { version = "1.10.0" }
+serde_json = { workspace = true }
+similar = { workspace = true, features = ["inline"] }
+shellexpand = { workspace = true }
+smallvec = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
-textwrap = { version = "0.16.0" }
-thiserror = { version = "1.0" }
-titlecase = { version = "2.2.1" }
+textwrap = { workspace = true }
+thiserror = { version = "1.0.38" }
 toml = { workspace = true }
-
-# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
-# For (future) wasm-pack support
-[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-getrandom = { version = "0.2.7", features = ["js"] }
-console_error_panic_hook = { version = "0.1.7" }
-console_log = { version = "0.2.0" }
-serde-wasm-bindgen = { version = "0.4" }
-js-sys = { version = "0.3.60" }
-wasm-bindgen = { version = "0.2.83" }
-
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-is_executable = "1.0.1"
+typed-arena = { version = "2.0.2" }
+unicode-width = { version = "0.1.10" }
 
 [dev-dependencies]
-insta = { version = "1.19.0", features = ["yaml", "redactions"] }
-test-case = { version = "2.2.2" }
-wasm-bindgen-test = { version = "0.3.33" }
-
-[target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
-criterion = { version = "0.4.0" }
+insta = { workspace = true }
+pretty_assertions = "1.3.0"
+test-case = { workspace = true }
+# Disable colored output in tests
+colored = { workspace = true, features = ["no-color"] }
 
 [features]
 default = []
 logical_lines = []
+jupyter_notebook = []

crates/ruff/resources/test/disallowed_rule_names.txt

@@ -2,3 +2,7 @@ avoid-*
 do-not-*
 uses-*
 *-used
+rewrite-*
+prefer-*
+consider-*
+use-*

crates/ruff/resources/test/fixtures/eradicate/ERA001.py

@@ -9,6 +9,7 @@ def foo(x, y, z):
     print(x, y, z)
 
     # This is a real comment.
+    # # This is a (nested) comment.
     #return True
     return False
 

crates/ruff/resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -107,3 +107,7 @@ class Foo:
     # ANN101
     def foo(self, /, a: int, b: int) -> int:
         pass
+
+
+# OK
+def f(*args: *tuple[int]) -> None: ...

crates/ruff/resources/test/fixtures/flake8_annotations/simple_magic_methods.py

@@ -0,0 +1,42 @@
+class Foo:
+    def __str__(self):
+        ...
+
+    def __repr__(self):
+        ...
+
+    def __len__(self):
+        ...
+
+    def __length_hint__(self):
+        ...
+
+    def __init__(self):
+        ...
+
+    def __del__(self):
+        ...
+
+    def __bool__(self):
+        ...
+
+    def __bytes__(self):
+        ...
+
+    def __format__(self, format_spec):
+        ...
+
+    def __contains__(self, item):
+        ...
+
+    def __complex__(self):
+        ...
+
+    def __int__(self):
+        ...
+
+    def __float__(self):
+        ...
+
+    def __index__(self):
+        ...

crates/ruff/resources/test/fixtures/flake8_bandit/S101.py

@@ -1,11 +1,13 @@
-# Error
-assert True
+assert True  # S101
+
 
 def fn():
     x = 1
+    assert x == 1  # S101
+    assert x == 2  # S101
 
-    # Error
-    assert x == 1
 
-    # Error
-    assert x == 2
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    assert True  # OK

crates/ruff/resources/test/fixtures/flake8_bandit/S105.py

@@ -19,6 +19,8 @@ token = "s3cr3t"
 secrete = "s3cr3t"
 safe = password = "s3cr3t"
 password = safe = "s3cr3t"
+PASSWORD = "s3cr3t"
+PassWord = "s3cr3t"
 
 d["password"] = "s3cr3t"
 d["pass"] = "s3cr3t"
@@ -61,3 +63,15 @@ if token == "3\t4":
 
 if token == "5\r6":
     pass
+
+
+# These should not be flagged
+passed_msg = "You have passed!"
+compassion = "Please don't match!"
+impassable = "You shall not pass!"
+passwords = ""
+PASSWORDS = ""
+passphrases = ""
+PassPhrases = ""
+tokens = ""
+secrets = ""

crates/ruff/resources/test/fixtures/flake8_bandit/S301.py

@@ -0,0 +1,3 @@
+import pickle
+
+pickle.loads()

crates/ruff/resources/test/fixtures/flake8_bandit/S312.py

@@ -0,0 +1,3 @@
+from telnetlib import Telnet
+
+Telnet("localhost", 23)

crates/ruff/resources/test/fixtures/flake8_bandit/S602.py

@@ -0,0 +1,20 @@
+from subprocess import Popen, call, check_call, check_output, run
+
+# Check different Popen wrappers are checked.
+Popen("true", shell=True)
+call("true", shell=True)
+check_call("true", shell=True)
+check_output("true", shell=True)
+run("true", shell=True)
+
+# Check values that truthy values are treated as true.
+Popen("true", shell=1)
+Popen("true", shell=[1])
+Popen("true", shell={1: 1})
+Popen("true", shell=(1,))
+
+# Check command argument looks unsafe.
+var_string = "true"
+Popen(var_string, shell=True)
+Popen([var_string], shell=True)
+Popen([var_string, ""], shell=True)

crates/ruff/resources/test/fixtures/flake8_bandit/S603.py

@@ -0,0 +1,20 @@
+from subprocess import Popen, call, check_call, check_output, run
+
+# Different Popen wrappers are checked.
+Popen("true", shell=False)
+call("true", shell=False)
+check_call("true", shell=False)
+check_output("true", shell=False)
+run("true", shell=False)
+
+# Values that falsey values are treated as false.
+Popen("true", shell=0)
+Popen("true", shell=[])
+Popen("true", shell={})
+Popen("true", shell=None)
+
+# Unknown values are treated as falsey.
+Popen("true", shell=True if True else False)
+
+# No value is also caught.
+Popen("true")

crates/ruff/resources/test/fixtures/flake8_bandit/S604.py

@@ -0,0 +1,5 @@
+def foo(shell):
+    pass
+
+
+foo(shell=True)

crates/ruff/resources/test/fixtures/flake8_bandit/S605.py

@@ -0,0 +1,25 @@
+import os
+
+import commands
+import popen2
+
+# Check all shell functions.
+os.system("true")
+os.popen("true")
+os.popen2("true")
+os.popen3("true")
+os.popen4("true")
+popen2.popen2("true")
+popen2.popen3("true")
+popen2.popen4("true")
+popen2.Popen3("true")
+popen2.Popen4("true")
+commands.getoutput("true")
+commands.getstatusoutput("true")
+
+
+# Check command argument looks unsafe.
+var_string = "true"
+os.system(var_string)
+os.system([var_string])
+os.system([var_string, ""])

crates/ruff/resources/test/fixtures/flake8_bandit/S606.py

@@ -0,0 +1,20 @@
+import os
+
+# Check all shell functions.
+os.execl("true")
+os.execle("true")
+os.execlp("true")
+os.execlpe("true")
+os.execv("true")
+os.execve("true")
+os.execvp("true")
+os.execvpe("true")
+os.spawnl("true")
+os.spawnle("true")
+os.spawnlp("true")
+os.spawnlpe("true")
+os.spawnv("true")
+os.spawnve("true")
+os.spawnvp("true")
+os.spawnvpe("true")
+os.startfile("true")

crates/ruff/resources/test/fixtures/flake8_bandit/S607.py

@@ -0,0 +1,44 @@
+import os
+
+# Check all functions.
+subprocess.Popen("true")
+subprocess.call("true")
+subprocess.check_call("true")
+subprocess.check_output("true")
+subprocess.run("true")
+os.system("true")
+os.popen("true")
+os.popen2("true")
+os.popen3("true")
+os.popen4("true")
+popen2.popen2("true")
+popen2.popen3("true")
+popen2.popen4("true")
+popen2.Popen3("true")
+popen2.Popen4("true")
+commands.getoutput("true")
+commands.getstatusoutput("true")
+os.execl("true")
+os.execle("true")
+os.execlp("true")
+os.execlpe("true")
+os.execv("true")
+os.execve("true")
+os.execvp("true")
+os.execvpe("true")
+os.spawnl("true")
+os.spawnle("true")
+os.spawnlp("true")
+os.spawnlpe("true")
+os.spawnv("true")
+os.spawnve("true")
+os.spawnvp("true")
+os.spawnvpe("true")
+os.startfile("true")
+
+# Check it does not fail for full paths.
+os.system("/bin/ls")
+os.system("./bin/ls")
+os.system(["/bin/ls"])
+os.system(["/bin/ls", "/tmp"])
+os.system(r"C:\\bin\ls")

crates/ruff/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -59,6 +59,10 @@ getattr(someobj, attrname, False)
 mylist.index(True)
 int(True)
 str(int(False))
+cfg.get("hello", True)
+cfg.getint("hello", True)
+cfg.getfloat("hello", True)
+cfg.getboolean("hello", True)
 
 
 class Registry:

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_B008.py

@@ -1,7 +1,9 @@
 import collections
 import datetime as dt
+from decimal import Decimal
 import logging
 import operator
+from pathlib import Path
 import random
 import re
 import time
@@ -165,6 +167,26 @@ def float_str_not_inf_or_nan_is_wrong(value=float("3.14")):
     pass
 
 
+# Allow decimals
+def decimal_okay(value=Decimal("0.1")):
+    pass
+
+# Allow dates
+def date_okay(value=dt.date(2023, 3, 27)):
+    pass
+
+# Allow datetimes
+def datetime_okay(value=dt.datetime(2023, 3, 27, 13, 51, 59)):
+    pass
+
+# Allow timedeltas
+def timedelta_okay(value=dt.timedelta(hours=1)):
+    pass
+
+# Allow paths
+def path_okay(value=Path(".")):
+    pass
+
 # B006 and B008
 # We should handle arbitrary nesting of these B008.
 def nested_combo(a=[float(3), dt.datetime.now()]):

crates/ruff/resources/test/fixtures/flake8_bugbear/B017.py

@@ -1,9 +1,10 @@
 """
 Should emit:
-B017 - on lines 20
+B017 - on lines 23 and 41
 """
 import asyncio
 import unittest
+import pytest
 
 CONSTANT = True
 
@@ -34,3 +35,14 @@ class Foobar(unittest.TestCase):
     def raises_with_absolute_reference(self):
         with self.assertRaises(asyncio.CancelledError):
             Foo()
+
+
+def test_pytest_raises():
+    with pytest.raises(Exception):
+        raise ValueError("Hello")
+
+    with pytest.raises(Exception, "hello"):
+        raise ValueError("This is fine")
+
+    with pytest.raises(Exception, match="hello"):
+        raise ValueError("This is also fine")

crates/ruff/resources/test/fixtures/flake8_bugbear/B018.py

@@ -57,3 +57,9 @@ def foo3():
 
 def foo4():
     ...
+
+
+def foo5():
+    foo.bar  # Attribute (raise)
+    object().__class__  # Attribute (raise)
+    "foo" + "bar"  # BinOp (raise)

crates/ruff/resources/test/fixtures/flake8_bugbear/B028.py

@@ -0,0 +1,11 @@
+import warnings
+
+"""
+Should emit:
+B028 - on lines 8 and 9
+"""
+
+warnings.warn(DeprecationWarning("test"))
+warnings.warn(DeprecationWarning("test"), source=None)
+warnings.warn(DeprecationWarning("test"), source=None, stacklevel=2)
+warnings.warn(DeprecationWarning("test"), stacklevel=1)

crates/ruff/resources/test/fixtures/flake8_bugbear/B030.py

@@ -0,0 +1,78 @@
+"""
+Should emit:
+B030:
+ - line 12, column 8
+ - line 17, column 9
+ - line 22, column 21
+ - line 27, column 37
+"""
+
+try:
+    pass
+except 1:  # error
+    pass
+
+try:
+    pass
+except (1, ValueError):  # error
+    pass
+
+try:
+    pass
+except (ValueError, (RuntimeError, (KeyError, TypeError))):  # error
+    pass
+
+try:
+    pass
+except (ValueError, *(RuntimeError, (KeyError, TypeError))):  # error
+    pass
+
+
+try:
+    pass
+except (*a, *(RuntimeError, (KeyError, TypeError))):  # error
+    pass
+
+try:
+    pass
+except (ValueError, *(RuntimeError, TypeError)):  # ok
+    pass
+
+try:
+    pass
+except (ValueError, *[RuntimeError, *(TypeError,)]):  # ok
+    pass
+
+
+try:
+    pass
+except (*a, *b):  # ok
+    pass
+
+
+try:
+    pass
+except (*a, *(RuntimeError, TypeError)):  # ok
+    pass
+
+
+try:
+    pass
+except (*a, *(b, c)):  # ok
+    pass
+
+
+try:
+    pass
+except (*a, *(*b, *c)):  # ok
+    pass
+
+
+def what_to_catch():
+    return ...
+
+
+try:
+    pass
+except what_to_catch():  # ok
+    pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B031.py

@@ -0,0 +1,187 @@
+import itertools
+from itertools import groupby
+
+shoppers = ["Jane", "Joe", "Sarah"]
+items = [
+    ("lettuce", "greens"),
+    ("tomatoes", "greens"),
+    ("cucumber", "greens"),
+    ("chicken breast", "meats & fish"),
+    ("salmon", "meats & fish"),
+    ("ice cream", "frozen items"),
+]
+
+carts = {shopper: [] for shopper in shoppers}
+
+
+def collect_shop_items(shopper, items):
+    # Imagine this an expensive database query or calculation that is
+    # advantageous to batch.
+    carts[shopper] += items
+
+
+# Invoking the `groupby` function directly
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    for shopper in shoppers:
+        shopper = shopper.title()
+        collect_shop_items(shopper, section_items)  # B031
+    # We're outside the nested loop and used the group again.
+    collect_shop_items(shopper, section_items)  # B031
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Joe", section_items)  # B031
+
+
+# Make sure to detect in other loop constructs as well - `while` loop
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    countdown = 3
+    while countdown > 0:
+        collect_shop_items(shopper, section_items)  # B031
+        countdown -= 1
+
+# Make sure to detect in other loop constructs as well - `list` comprehension
+collection = []
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    collection.append([list(section_items) for _ in range(3)])  # B031
+
+unique_items = set()
+another_set = set()
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # For nested loops, it should not flag the usage of the name
+    for item in section_items:
+        unique_items.add(item)
+
+    # But it should be detected when used again
+    for item in section_items:  # B031
+        another_set.add(item)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # Variable has been overridden, skip checking
+    section_items = list(unique_items)
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Jane", section_items)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # Variable has been overridden, skip checking
+    # Not a realistic situation, just for testing purpose
+    (section_items := list(unique_items))
+    collect_shop_items("Jane", section_items)
+    collect_shop_items("Jane", section_items)
+
+for _section, section_items in groupby(items, key=lambda p: p[1]):
+    # This is ok
+    collect_shop_items("Jane", section_items)
+
+# Invocation via the `itertools` module
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    for shopper in shoppers:
+        collect_shop_items(shopper, section_items)  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    _ = [collect_shop_items(shopper, section_items) for shopper in shoppers]  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # The variable is overridden, skip checking.
+    _ = [_ for section_items in range(3)]
+    _ = [collect_shop_items(shopper, section_items) for shopper in shoppers]
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    _ = [item for item in section_items]
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # The iterator is being used for the second time.
+    _ = [(item1, item2) for item1 in section_items for item2 in section_items]  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    if _section == "greens":
+        collect_shop_items(shopper, section_items)
+    else:
+        collect_shop_items(shopper, section_items)
+        collect_shop_items(shopper, section_items)  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # Mutually exclusive branches shouldn't trigger the warning
+    if _section == "greens":
+        collect_shop_items(shopper, section_items)
+        if _section == "greens":
+            collect_shop_items(shopper, section_items)  # B031
+        elif _section == "frozen items":
+            collect_shop_items(shopper, section_items)  # B031
+        else:
+            collect_shop_items(shopper, section_items)  # B031
+        collect_shop_items(shopper, section_items)  # B031
+    elif _section == "frozen items":
+        # Mix `match` and `if` statements
+        match shopper:
+            case "Jane":
+                collect_shop_items(shopper, section_items)
+                if _section == "fourth":
+                    collect_shop_items(shopper, section_items)  # B031
+            case _:
+                collect_shop_items(shopper, section_items)
+    else:
+        collect_shop_items(shopper, section_items)
+    # Now, it should detect
+    collect_shop_items(shopper, section_items)  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # Mutually exclusive branches shouldn't trigger the warning
+    match _section:
+        case "greens":
+            collect_shop_items(shopper, section_items)
+            match shopper:
+                case "Jane":
+                    collect_shop_items(shopper, section_items)  # B031
+                case _:
+                    collect_shop_items(shopper, section_items)  # B031
+        case "frozen items":
+            collect_shop_items(shopper, section_items)
+            collect_shop_items(shopper, section_items)  # B031
+        case _:
+            collect_shop_items(shopper, section_items)
+    # Now, it should detect
+    collect_shop_items(shopper, section_items)  # B031
+
+for group in groupby(items, key=lambda p: p[1]):
+    # This is bad, but not detected currently
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+
+# https://github.com/charliermarsh/ruff/issues/4050
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    if _section == "greens":
+        for item in section_items:
+            collect_shop_items(shopper, item)
+    elif _section == "frozen items":
+        _ = [item for item in section_items]
+    else:
+        collect_shop_items(shopper, section_items)
+
+#  Make sure we ignore - but don't fail on more complicated invocations
+for _key, (_value1, _value2) in groupby(
+    [("a", (1, 2)), ("b", (3, 4)), ("a", (5, 6))], key=lambda p: p[1]
+):
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+#  Make sure we ignore - but don't fail on more complicated invocations
+for (_key1, _key2), (_value1, _value2) in groupby(
+    [(("a", "a"), (1, 2)), (("b", "b"), (3, 4)), (("a", "a"), (5, 6))],
+    key=lambda p: p[1],
+):
+    collect_shop_items("Jane", group[1])
+    collect_shop_items("Joe", group[1])
+
+
+# Let's redefine the `groupby` function to make sure we pick up the correct one.
+# NOTE: This should always be at the end of the file.
+def groupby(data, key=None):
+    pass
+
+
+for name, group in groupby(items):
+    collect_shop_items("Jane", items)
+    # This shouldn't be flagged as the `groupby` function is different
+    collect_shop_items("Joe", items)

crates/ruff/resources/test/fixtures/flake8_commas/COM81.py

@@ -626,3 +626,8 @@ result = function(
     bar,
     **{'ham': spam}
 )
+
+# Make sure the COM812 and UP034 rules don't autofix simultaneously and cause a syntax error.
+the_first_one = next(
+    (i for i in range(10) if i // 2 == 0)  # COM812 fix should include the final bracket
+)

crates/ruff/resources/test/fixtures/flake8_comprehensions/C414.py

@@ -7,11 +7,14 @@ set(set(x))
 set(list(x))
 set(tuple(x))
 set(sorted(x))
+set(sorted(x, key=lambda y: y))
 set(reversed(x))
 sorted(list(x))
 sorted(tuple(x))
 sorted(sorted(x))
+sorted(sorted(x, key=lambda y: y))
 sorted(reversed(x))
+sorted(list(x), key=lambda y: y)
 tuple(
     list(
         [x, 3, "hell"\

crates/ruff/resources/test/fixtures/flake8_comprehensions/C416.py

@@ -1,6 +1,19 @@
 x = [1, 2, 3]
+y = [("a", 1), ("b", 2), ("c", 3)]
+z = [(1,), (2,), (3,)]
+d = {"a": 1, "b": 2, "c": 3}
+
 [i for i in x]
 {i for i in x}
+{k: v for k, v in y}
+{k: v for k, v in d.items()}
 
+[i for i, in z]
+[i for i, j in y]
 [i for i in x if i > 1]
 [i for i in x for j in x]
+
+{v: k for k, v in y}
+{k.foo: k for k in y}
+{k["foo"]: k for k in y}
+{k: v if v else None for k, v in y}

crates/ruff/resources/test/fixtures/flake8_comprehensions/C418.py

@@ -0,0 +1,10 @@
+dict({})
+dict({'a': 1})
+dict({'x': 1 for x in range(10)})
+dict(
+    {'x': 1 for x in range(10)}
+)
+
+dict({}, a=1)
+dict({x: 1 for x in range(1)}, a=1)
+

crates/ruff/resources/test/fixtures/flake8_comprehensions/C419.py

@@ -0,0 +1,19 @@
+any([x.id for x in bar])
+all([x.id for x in bar])
+any(  # first comment
+    [x.id for x in bar],  # second comment
+)  # third comment
+all(  # first comment
+    [x.id for x in bar],  # second comment
+)  # third comment
+any({x.id for x in bar})
+
+# OK
+all(x.id for x in bar)
+all(x.id for x in bar)
+any(x.id for x in bar)
+all((x.id for x in bar))
+
+
+async def f() -> bool:
+    return all([await use_greeting(greeting) for greeting in await greetings()])

crates/ruff/resources/test/fixtures/flake8_django/DJ003.py

@@ -0,0 +1,21 @@
+from django.shortcuts import render
+
+
+def test_view1(request):
+    return render(request, "index.html", locals())
+
+
+def test_view2(request):
+    return render(request, "index.html", context=locals())
+
+
+def test_view3(request):
+    return render(request, "index.html")
+
+
+def test_view4(request):
+    return render(request, "index.html", {})
+
+
+def test_view5(request):
+    return render(request, "index.html", context={})

crates/ruff/resources/test/fixtures/flake8_django/DJ006.py

@@ -0,0 +1,11 @@
+from django import forms
+
+
+class TestModelForm1(forms.ModelForm):
+    class Meta:
+        exclude = ["bar"]
+
+
+class TestModelForm2(forms.ModelForm):
+    class Meta:
+        fields = ["foo"]

crates/ruff/resources/test/fixtures/flake8_django/DJ007.py

@@ -0,0 +1,16 @@
+from django import forms
+
+
+class TestModelForm1(forms.ModelForm):
+    class Meta:
+        fields = "__all__"
+
+
+class TestModelForm2(forms.ModelForm):
+    class Meta:
+        fields = b"__all__"
+
+
+class TestModelForm3(forms.ModelForm):
+    class Meta:
+        fields = ["foo"]

crates/ruff/resources/test/fixtures/flake8_django/DJ012.py

@@ -0,0 +1,113 @@
+from django.db import models
+from django.db.models import Model
+
+
+class StrBeforeRandomField(models.Model):
+    """Model with `__str__` before a random property."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return ""
+
+    random_property = "foo"
+
+
+class StrBeforeFieldModel(models.Model):
+    """Model with `__str__` before fields."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "foobar"
+
+    first_name = models.CharField(max_length=32)
+
+
+class ManagerBeforeField(models.Model):
+    """Model with manager before fields."""
+
+    objects = "manager"
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "foobar"
+
+    first_name = models.CharField(max_length=32)
+
+
+class CustomMethodBeforeStr(models.Model):
+    """Model with a custom method before `__str__`."""
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def my_method(self):
+        pass
+
+    def __str__(self):
+        return "foobar"
+
+
+class GetAbsoluteUrlBeforeSave(Model):
+    """Model with `get_absolute_url` method before `save` method.
+
+    Subclass this directly using the `Model` class.
+    """
+
+    def get_absolute_url(self):
+        pass
+
+    def save(self):
+        pass
+
+
+class ConstantsAreNotFields(models.Model):
+    """Model with an assignment to a constant after `__str__`."""
+
+    first_name = models.CharField(max_length=32)
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        pass
+
+    MY_CONSTANT = id(1)
+
+
+class PerfectlyFine(models.Model):
+    """Model which has everything in perfect order."""
+
+    first_name = models.CharField(max_length=32)
+    last_name = models.CharField(max_length=32)
+    objects = "manager"
+
+    class Meta:
+        verbose_name = "test"
+        verbose_name_plural = "tests"
+
+    def __str__(self):
+        return "Perfectly fine!"
+
+    def save(self, **kwargs):
+        super(PerfectlyFine, self).save(**kwargs)
+
+    def get_absolute_url(self):
+        return "http://%s" % self
+
+    def my_method(self):
+        pass
+
+    @property
+    def random_property(self):
+        return "%s" % self

crates/ruff/resources/test/fixtures/flake8_gettext/INT001.py

@@ -0,0 +1 @@
+_(f"{'value'}")

crates/ruff/resources/test/fixtures/flake8_gettext/INT002.py

@@ -0,0 +1 @@
+_("{}".format("line"))

crates/ruff/resources/test/fixtures/flake8_gettext/INT003.py

@@ -0,0 +1 @@
+_("%s" % "line")

crates/ruff/resources/test/fixtures/flake8_import_conventions/custom_banned.py

@@ -0,0 +1,16 @@
+import typing as t  # banned
+import typing as ty  # banned
+
+import numpy as nmp  # banned
+import numpy as npy  # banned
+import tensorflow.keras.backend as K  # banned
+import torch.nn.functional as F  # banned
+from tensorflow.keras import backend as K  # banned
+from torch.nn import functional as F  # banned
+
+from typing import Any  # ok
+
+import numpy as np  # ok
+import tensorflow as tf  # ok
+import torch.nn as nn  # ok
+from tensorflow.keras import backend  # ok

crates/ruff/resources/test/fixtures/flake8_import_conventions/custom_banned_from.py

@@ -0,0 +1,10 @@
+from logging.config import BaseConfigurator  # banned
+from typing import Any, Dict  # banned
+from typing import *  # banned
+
+from pandas import DataFrame  # banned
+from pandas import *  # banned
+
+import logging.config  # ok
+import typing  # ok
+import pandas  # ok

crates/ruff/resources/test/fixtures/flake8_logging_format/G001.py

@@ -1,3 +1,9 @@
 import logging
+import logging as foo
 
 logging.info("Hello {}".format("World!"))
+logging.log(logging.INFO, "Hello {}".format("World!"))
+foo.info("Hello {}".format("World!"))
+logging.log(logging.INFO, msg="Hello {}".format("World!"))
+logging.log(level=logging.INFO, msg="Hello {}".format("World!"))
+logging.log(msg="Hello {}".format("World!"), level=logging.INFO)

crates/ruff/resources/test/fixtures/flake8_logging_format/G002.py

@@ -1,3 +1,4 @@
 import logging
 
 logging.info("Hello %s" % "World!")
+logging.log(logging.INFO, "Hello %s" % "World!")

crates/ruff/resources/test/fixtures/flake8_logging_format/G003.py

@@ -1,3 +1,4 @@
 import logging
 
 logging.info("Hello" + " " + "World!")
+logging.log(logging.INFO, "Hello" + " " + "World!")

crates/ruff/resources/test/fixtures/flake8_logging_format/G004.py

@@ -2,3 +2,4 @@ import logging
 
 name = "world"
 logging.info(f"Hello {name}")
+logging.log(logging.INFO, f"Hello {name}")

crates/ruff/resources/test/fixtures/flake8_logging_format/G010.py

@@ -1,3 +1,5 @@
 import logging
+from distutils import log
 
 logging.warn("Hello World!")
+log.warn("Hello world!")  # This shouldn't be considered as a logger candidate

crates/ruff/resources/test/fixtures/flake8_pie/PIE807.py

@@ -18,3 +18,10 @@ class Foo:
 
 class FooTable(BaseTable):
     bar = fields.ListField(list)
+
+
+lambda *args, **kwargs: []
+
+lambda *args: []
+
+lambda **kwargs: []

crates/ruff/resources/test/fixtures/flake8_pie/PIE810.py

@@ -6,6 +6,8 @@ obj.endswith("foo") or obj.endswith("bar")
 obj.startswith(foo) or obj.startswith(bar)
 # error
 obj.startswith(foo) or obj.startswith("foo")
+# error
+obj.endswith(foo) or obj.startswith(foo) or obj.startswith("foo")
 
 # ok
 obj.startswith(("foo",  "bar"))

crates/ruff/resources/test/fixtures/flake8_pyi/PYI001.py

@@ -11,3 +11,7 @@ _T = TypeVar("_T")  # OK
 _TTuple = TypeVarTuple("_TTuple")  # OK
 
 _P = ParamSpec("_P")  # OK
+
+
+def f():
+    T = TypeVar("T")  # OK

crates/ruff/resources/test/fixtures/flake8_pyi/PYI001.pyi

@@ -11,3 +11,6 @@ _T = TypeVar("_T")  # OK
 _TTuple = TypeVarTuple("_TTuple")  # OK
 
 _P = ParamSpec("_P")  # OK
+
+def f():
+    T = TypeVar("T")  # OK

crates/ruff/resources/test/fixtures/flake8_pyi/PYI006.py

@@ -0,0 +1,14 @@
+import sys
+from sys import version_info as python_version
+
+if sys.version_info < (3, 9): ...  # OK
+
+if sys.version_info >= (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # OK
+
+if sys.version_info <= (3, 10): ...  # OK
+
+if sys.version_info > (3, 10): ...  # OK
+
+if python_version > (3, 10): ...  # OK

crates/ruff/resources/test/fixtures/flake8_pyi/PYI006.pyi

@@ -0,0 +1,18 @@
+import sys
+from sys import version_info as python_version
+
+if sys.version_info < (3, 9): ...  # OK
+
+if sys.version_info >= (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # OK
+
+if sys.version_info == (3, 9): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info <= (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if sys.version_info > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons
+
+if python_version > (3, 10): ...  # Error: PYI006 Use only `<` and `>=` for version info comparisons

crates/ruff/resources/test/fixtures/flake8_pyi/PYI009.py

@@ -0,0 +1,14 @@
+def bar():
+    ...  # OK
+
+
+def foo():
+    pass  # OK, since we're not in a stub file
+
+
+class Bar:
+    ...  # OK
+
+
+class Foo:
+    pass  # OK, since we're not in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI009.pyi

@@ -0,0 +1,8 @@
+def bar(): ...  # OK
+def foo():
+    pass  # ERROR PYI009, since we're in a stub file
+
+class Bar: ...  # OK
+
+class Foo:
+    pass  # ERROR PYI009, since we're in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI010.py

@@ -0,0 +1,18 @@
+def bar():
+    ...  # OK
+
+
+def foo():
+    """foo"""  # OK
+
+
+def buzz():
+    print("buzz")  # OK, not in stub file
+
+
+def foo2():
+    123  # OK, not in a stub file
+
+
+def bizz():
+    x = 123  # OK, not in a stub file

crates/ruff/resources/test/fixtures/flake8_pyi/PYI010.pyi

@@ -0,0 +1,12 @@
+def bar(): ...  # OK
+def foo():
+    """foo"""  # OK, strings are handled by another rule
+
+def buzz():
+    print("buzz")  # ERROR PYI010
+
+def foo2():
+    123  # ERROR PYI010
+
+def bizz():
+    x = 123  # ERROR PYI010

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.py

@@ -0,0 +1,161 @@
+import math
+import os
+import sys
+from math import inf
+
+import numpy as np
+
+def f12(
+    x,
+    y: str = os.pathsep,  # OK
+) -> None: ...
+def f11(*, x: str = "x") -> None: ...  # OK
+def f13(
+    x: list[str] = [  # OK
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None: ...
+def f14(
+    x: tuple[str, ...] = (  # OK
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None: ...
+def f15(
+    x: set[str] = {  # OK
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None: ...
+def f151(x: dict[int, int] = {1: 2}) -> None: ...  # Ok
+def f152(
+    x: dict[
+        int, int
+    ] = {  # OK
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x: list[
+        int
+    ] = [  # OK
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x: tuple[
+        str, tuple[str, ...]
+    ] = (  # OK
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x: list[
+        int
+    ] = [  # OK
+        *range(10)
+    ],
+) -> None: ...
+def f142(
+    x: list[
+        int
+    ] = list(  # OK
+        range(10)
+    ),
+) -> None: ...
+def f16(
+    x: frozenset[
+        bytes
+    ] = frozenset(  # OK
+        {b"foo", b"bar", b"baz"}
+    )
+) -> None: ...
+def f17(
+    x: str = "foo"  # OK
+    + "bar",
+) -> None: ...
+def f18(
+    x: str = b"foo"  # OK
+    + b"bar",
+) -> None: ...
+def f19(
+    x: object = "foo"  # OK
+    + 4,
+) -> None: ...
+def f20(
+    x: int = 5
+    + 5,  # OK
+) -> None: ...
+def f21(
+    x: complex = 3j
+    - 3j,  # OK
+) -> None: ...
+def f22(
+    x: complex = -42.5j  # OK
+    + 4.3j,
+) -> None: ...
+def f23(
+    x: bool = True,  # OK
+) -> None: ...
+def f24(
+    x: float = 3.14,  # OK
+) -> None: ...
+def f25(
+    x: float = -3.14,  # OK
+) -> None: ...
+def f26(
+    x: complex = -3.14j,  # OK
+) -> None: ...
+def f27(
+    x: complex = -3 - 3.14j,  # OK
+) -> None: ...
+def f28(
+    x: float = math.tau,  # OK
+) -> None: ...
+def f29(
+    x: float = math.inf,  # OK
+) -> None: ...
+def f30(
+    x: float = -math.inf,  # OK
+) -> None: ...
+def f31(
+    x: float = inf,  # OK
+) -> None: ...
+def f32(
+    x: float = np.inf,  # OK
+) -> None: ...
+def f33(
+    x: float = math.nan,  # OK
+) -> None: ...
+def f34(
+    x: float = -math.nan,  # OK
+) -> None: ...
+def f35(
+    x: complex = math.inf  # OK
+    + 1j,
+) -> None: ...
+def f36(
+    *,
+    x: str = sys.version,  # OK
+) -> None: ...
+def f37(
+    *,
+    x: str = ""  # OK
+    + "",
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI011.pyi

@@ -0,0 +1,161 @@
+import math
+import os
+import sys
+from math import inf
+
+import numpy as np
+
+def f12(
+    x,
+    y: str = os.pathsep,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f11(*, x: str = "x") -> None: ...  # OK
+def f13(
+    x: list[str] = [  # OK
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None: ...
+def f14(
+    x: tuple[str, ...] = (  # OK
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None: ...
+def f15(
+    x: set[str] = {  # OK
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None: ...
+def f151(x: dict[int, int] = {1: 2}) -> None: ...  # Ok
+def f152(
+    x: dict[
+        int, int
+    ] = {  # Error PYI011 Only simple default values allowed for typed arguments
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x: list[
+        int
+    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x: tuple[
+        str, tuple[str, ...]
+    ] = (  # Error PYI011 Only simple default values allowed for typed arguments
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x: list[
+        int
+    ] = [  # Error PYI011 Only simple default values allowed for typed arguments
+        *range(10)
+    ],
+) -> None: ...
+def f142(
+    x: list[
+        int
+    ] = list(  # Error PYI011 Only simple default values allowed for typed arguments
+        range(10)
+    ),
+) -> None: ...
+def f16(
+    x: frozenset[
+        bytes
+    ] = frozenset(  # Error PYI011 Only simple default values allowed for typed arguments
+        {b"foo", b"bar", b"baz"}
+    )
+) -> None: ...
+def f17(
+    x: str = "foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + "bar",
+) -> None: ...
+def f18(
+    x: str = b"foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + b"bar",
+) -> None: ...
+def f19(
+    x: object = "foo"  # Error PYI011 Only simple default values allowed for typed arguments
+    + 4,
+) -> None: ...
+def f20(
+    x: int = 5
+    + 5,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f21(
+    x: complex = 3j
+    - 3j,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f22(
+    x: complex = -42.5j  # Error PYI011 Only simple default values allowed for typed arguments
+    + 4.3j,
+) -> None: ...
+def f23(
+    x: bool = True,  # OK
+) -> None: ...
+def f24(
+    x: float = 3.14,  # OK
+) -> None: ...
+def f25(
+    x: float = -3.14,  # OK
+) -> None: ...
+def f26(
+    x: complex = -3.14j,  # OK
+) -> None: ...
+def f27(
+    x: complex = -3 - 3.14j,  # OK
+) -> None: ...
+def f28(
+    x: float = math.tau,  # OK
+) -> None: ...
+def f29(
+    x: float = math.inf,  # OK
+) -> None: ...
+def f30(
+    x: float = -math.inf,  # OK
+) -> None: ...
+def f31(
+    x: float = inf,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f32(
+    x: float = np.inf,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f33(
+    x: float = math.nan,  # OK
+) -> None: ...
+def f34(
+    x: float = -math.nan,  # Error PYI011 Only simple default values allowed for typed arguments
+) -> None: ...
+def f35(
+    x: complex = math.inf  # Error PYI011 Only simple default values allowed for typed arguments
+    + 1j,
+) -> None: ...
+def f36(
+    *,
+    x: str = sys.version,  # OK
+) -> None: ...
+def f37(
+    *,
+    x: str = ""  # Error PYI011 Only simple default values allowed for typed arguments
+    + "",
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI012.py

@@ -0,0 +1,75 @@
+# Violations of PYI012
+
+
+class OneAttributeClass:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class OneAttributeClassRev:
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+
+class DocstringClass:
+    """
+    My body only contains pass.
+    """
+
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class NonEmptyChild(Exception):
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+
+class NonEmptyChild2(Exception):
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+
+class NonEmptyWithInit:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+    def __init__():
+        pass
+
+
+# Not violations (of PYI012)
+
+
+class EmptyClass:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+
+class EmptyOneLine:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+
+class Dog:
+    eyes: int = 2
+
+
+class EmptyEllipsis:
+    ...
+
+
+class NonEmptyEllipsis:
+    value: int
+    ...  # Y013 Non-empty class body must not contain `...`
+
+
+class WithInit:
+    value: int = 0
+
+    def __init__():
+        pass
+
+
+def function():
+    pass
+
+
+pass

crates/ruff/resources/test/fixtures/flake8_pyi/PYI012.pyi

@@ -0,0 +1,59 @@
+# Violations of PYI012
+
+class OneAttributeClass:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+class OneAttributeClassRev:
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+class DocstringClass:
+    """
+    My body only contains pass.
+    """
+
+    pass  # PYI012 Class body must not contain `pass`
+
+class NonEmptyChild(Exception):
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+class NonEmptyChild2(Exception):
+    pass  # PYI012 Class body must not contain `pass`
+    value: int
+
+class NonEmptyWithInit:
+    value: int
+    pass  # PYI012 Class body must not contain `pass`
+
+    def __init__():
+        pass
+
+# Not violations (of PYI012)
+
+class EmptyClass:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+class EmptyOneLine:
+    pass  # Y009 Empty body should contain `...`, not `pass`
+
+class Dog:
+    eyes: int = 2
+
+class EmptyEllipsis: ...
+
+class NonEmptyEllipsis:
+    value: int
+    ...  # Y013 Non-empty class body must not contain `...`
+
+class WithInit:
+    value: int = 0
+
+    def __init__():
+        pass
+
+def function():
+    pass
+
+pass

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.py

@@ -0,0 +1,131 @@
+def f12(
+    x,
+    y=os.pathsep,  # OK
+) -> None:
+    ...
+
+
+def f11(*, x="x") -> None:
+    ...  # OK
+
+
+def f13(
+    x=[  # OK
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None:
+    ...
+
+
+def f14(
+    x=(  # OK
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None:
+    ...
+
+
+def f15(
+    x={  # OK
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None:
+    ...
+
+
+def f151(x={1: 2}) -> None:  # Ok
+    ...
+
+
+def f152(
+    x={  # OK
+        1: 2,
+        **{3: 4},
+    }
+) -> None:
+    ...
+
+
+def f153(
+    x=[  # OK
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None:
+    ...
+
+
+def f154(
+    x=(  # OK
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None:
+    ...
+
+
+def f141(
+    x=[*range(10)],  # OK
+) -> None:
+    ...
+
+
+def f142(
+    x=list(range(10)),  # OK
+) -> None:
+    ...
+
+
+def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None:
+    ...  # OK
+
+
+def f17(
+    x="foo" + "bar",  # OK
+) -> None:
+    ...
+
+
+def f18(
+    x=b"foo" + b"bar",  # OK
+) -> None:
+    ...
+
+
+def f19(
+    x="foo" + 4,  # OK
+) -> None:
+    ...
+
+
+def f20(
+    x=5 + 5,  # OK
+) -> None:
+    ...
+
+
+def f21(
+    x=3j - 3j,  # OK
+) -> None:
+    ...
+
+
+def f22(
+    x=-42.5j + 4.3j,  # OK
+) -> None:
+    ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI014.pyi

@@ -0,0 +1,82 @@
+def f12(
+    x,
+    y=os.pathsep,  # Error PYI014
+) -> None: ...
+def f11(*, x="x") -> None: ...  # OK
+def f13(
+    x=[  # OK
+        "foo",
+        "bar",
+        "baz",
+    ]
+) -> None: ...
+def f14(
+    x=(  # OK
+        "foo",
+        "bar",
+        "baz",
+    )
+) -> None: ...
+def f15(
+    x={  # OK
+        "foo",
+        "bar",
+        "baz",
+    }
+) -> None: ...
+def f151(x={1: 2}) -> None: ...
+def f152(
+    x={  # Error PYI014
+        1: 2,
+        **{3: 4},
+    }
+) -> None: ...
+def f153(
+    x=[  # Error PYI014
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+    ]
+) -> None: ...
+def f154(
+    x=(  # Error PYI014
+        "foo",
+        ("bar", "baz"),
+    )
+) -> None: ...
+def f141(
+    x=[*range(10)],  # Error PYI014
+) -> None: ...
+def f142(
+    x=list(range(10)),  # Error PYI014
+) -> None: ...
+def f16(x=frozenset({b"foo", b"bar", b"baz"})) -> None: ...  # Error PYI014
+def f17(
+    x="foo" + "bar",  # Error PYI014
+) -> None: ...
+def f18(
+    x=b"foo" + b"bar",  # Error PYI014
+) -> None: ...
+def f19(
+    x="foo" + 4,  # Error PYI014
+) -> None: ...
+def f20(
+    x=5 + 5,  # Error PYI014
+) -> None: ...
+def f21(
+    x=3j - 3j,  # Error PYI014
+) -> None: ...
+def f22(
+    x=-42.5j + 4.3j,  # Error PYI014
+) -> None: ...
+def f23(
+    x=True,  # OK
+) -> None: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI015.py

@@ -0,0 +1,93 @@
+import builtins
+import typing
+from typing import TypeAlias, Final
+
+field1: int
+field2: int = ...
+field3 = ...  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+field4: int = 0
+field41: int = 0xFFFFFFFF
+field42: int = 1234567890
+field43: int = -0xFFFFFFFF
+field44: int = -1234567890
+field5 = 0  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")  # Y052 Need type annotation for "field5"
+field6 = 0  # Y052 Need type annotation for "field6"
+field7 = b""  # Y052 Need type annotation for "field7"
+field71 = "foo"  # Y052 Need type annotation for "field71"
+field72: str = "foo"
+field8 = False  # Y052 Need type annotation for "field8"
+field81 = -1  # Y052 Need type annotation for "field81"
+field82: float = -98.43
+field83 = -42j  # Y052 Need type annotation for "field83"
+field84 = 5 + 42j  # Y052 Need type annotation for "field84"
+field85 = -5 - 42j  # Y052 Need type annotation for "field85"
+field9 = None  # Y026 Use typing_extensions.TypeAlias for type aliases, e.g. "field9: TypeAlias = None"
+Field95: TypeAlias = None
+Field96: TypeAlias = int | None
+Field97: TypeAlias = None | typing.SupportsInt | builtins.str | float | bool
+field19 = [1, 2, 3]  # Y052 Need type annotation for "field19"
+field191: list[int] = [1, 2, 3]
+field20 = (1, 2, 3)  # Y052 Need type annotation for "field20"
+field201: tuple[int, ...] = (1, 2, 3)
+field21 = {1, 2, 3}  # Y052 Need type annotation for "field21"
+field211: set[int] = {1, 2, 3}
+field212 = {"foo": "bar"}  # Y052 Need type annotation for "field212"
+field213: dict[str, str] = {"foo": "bar"}
+field22: Final = {"foo": 5}
+field221: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]  # Y015 Only simple default values are allowed for assignments
+field223: list[int] = [*range(10)]  # Y015 Only simple default values are allowed for assignments
+field224: list[int] = list(range(10))  # Y015 Only simple default values are allowed for assignments
+field225: list[object] = [{}, 1, 2]  # Y015 Only simple default values are allowed for assignments
+field226: tuple[str | tuple[str, ...], ...] = ("foo", ("foo", "bar"))  # Y015 Only simple default values are allowed for assignments
+field227: dict[str, object] = {"foo": {"foo": "bar"}}  # Y015 Only simple default values are allowed for assignments
+field228: dict[str, list[object]] = {"foo": []}  # Y015 Only simple default values are allowed for assignments
+# When parsed, this case results in `None` being placed in the `.keys` list for the `ast.Dict` node
+field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values are allowed for assignments
+field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
+field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
+field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments
+
+# We shouldn't emit Y015 within functions
+def f():
+  field26: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+
+# We shouldn't emit Y015 for __slots__ or __match_args__
+class Class1:
+  __slots__ = (
+    '_one',
+    '_two',
+    '_three',
+    '_four',
+    '_five',
+    '_six',
+    '_seven',
+    '_eight',
+    '_nine',
+    '_ten',
+    '_eleven',
+  )
+
+  __match_args__ = (
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+    'eleven',
+  )
+
+# We shouldn't emit Y015 for __all__
+__all__ = ["Class1"]
+
+# Ignore the following for PYI015
+field26 = typing.Sequence[int]
+field27 = list[str]
+field28 = builtins.str
+field29 = str
+field30 = str | bytes | None

crates/ruff/resources/test/fixtures/flake8_pyi/PYI015.pyi

@@ -0,0 +1,100 @@
+import builtins
+import typing
+from typing import TypeAlias, Final, NewType, TypeVar, TypeVarTuple, ParamSpec
+
+# We shouldn't emit Y015 for simple default values
+field1: int
+field2: int = ...
+field3 = ...  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+field4: int = 0
+field41: int = 0xFFFFFFFF
+field42: int = 1234567890
+field43: int = -0xFFFFFFFF
+field44: int = -1234567890
+field5 = 0  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")  # Y052 Need type annotation for "field5"
+field6 = 0  # Y052 Need type annotation for "field6"
+field7 = b""  # Y052 Need type annotation for "field7"
+field71 = "foo"  # Y052 Need type annotation for "field71"
+field72: str = "foo"
+field8 = False  # Y052 Need type annotation for "field8"
+field81 = -1  # Y052 Need type annotation for "field81"
+field82: float = -98.43
+field83 = -42j  # Y052 Need type annotation for "field83"
+field84 = 5 + 42j  # Y052 Need type annotation for "field84"
+field85 = -5 - 42j  # Y052 Need type annotation for "field85"
+field9 = None  # Y026 Use typing_extensions.TypeAlias for type aliases, e.g. "field9: TypeAlias = None"
+Field95: TypeAlias = None
+Field96: TypeAlias = int | None
+Field97: TypeAlias = None | typing.SupportsInt | builtins.str | float | bool
+Field98 = NewType('MyInt', int)
+Field99 = TypeVar('Field99')
+Field100 = TypeVarTuple('Field100')
+Field101 = ParamSpec('Field101')
+field19 = [1, 2, 3]  # Y052 Need type annotation for "field19"
+field191: list[int] = [1, 2, 3]
+field20 = (1, 2, 3)  # Y052 Need type annotation for "field20"
+field201: tuple[int, ...] = (1, 2, 3)
+field21 = {1, 2, 3}  # Y052 Need type annotation for "field21"
+field211: set[int] = {1, 2, 3}
+field212 = {"foo": "bar"}  # Y052 Need type annotation for "field212"
+field213: dict[str, str] = {"foo": "bar"}
+field22: Final = {"foo": 5}
+
+# We *should* emit Y015 for more complex default values
+field221: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]  # Y015 Only simple default values are allowed for assignments
+field223: list[int] = [*range(10)]  # Y015 Only simple default values are allowed for assignments
+field224: list[int] = list(range(10))  # Y015 Only simple default values are allowed for assignments
+field225: list[object] = [{}, 1, 2]  # Y015 Only simple default values are allowed for assignments
+field226: tuple[str | tuple[str, ...], ...] = ("foo", ("foo", "bar"))  # Y015 Only simple default values are allowed for assignments
+field227: dict[str, object] = {"foo": {"foo": "bar"}}  # Y015 Only simple default values are allowed for assignments
+field228: dict[str, list[object]] = {"foo": []}  # Y015 Only simple default values are allowed for assignments
+# When parsed, this case results in `None` being placed in the `.keys` list for the `ast.Dict` node
+field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values are allowed for assignments
+field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
+field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
+field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments
+
+# We shouldn't emit Y015 within functions
+def f():
+  field26: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+
+# We shouldn't emit Y015 for __slots__ or __match_args__
+class Class1:
+  __slots__ = (
+    '_one',
+    '_two',
+    '_three',
+    '_four',
+    '_five',
+    '_six',
+    '_seven',
+    '_eight',
+    '_nine',
+    '_ten',
+    '_eleven',
+  )
+
+  __match_args__ = (
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+    'eleven',
+  )
+
+# We shouldn't emit Y015 for __all__
+__all__ = ["Class1"]
+
+# Ignore the following for PYI015
+field26 = typing.Sequence[int]
+field27 = list[str]
+field28 = builtins.str
+field29 = str
+field30 = str | bytes | None

crates/ruff/resources/test/fixtures/flake8_pyi/PYI016.py

@@ -0,0 +1,35 @@
+# Shouldn't affect non-union field types.
+field1: str
+
+# Should emit for duplicate field types.
+field2: str | str  # PYI016: Duplicate union member `str`
+
+
+# Should emit for union types in arguments.
+def func1(arg1: int | int):  # PYI016: Duplicate union member `int`
+    print(arg1)
+
+
+# Should emit for unions in return types.
+def func2() -> str | str:  # PYI016: Duplicate union member `str`
+    return "my string"
+
+
+# Should emit in longer unions, even if not directly adjacent.
+field3: str | str | int  # PYI016: Duplicate union member `str`
+field4: int | int | str  # PYI016: Duplicate union member `int`
+field5: str | int | str  # PYI016: Duplicate union member `str`
+field6: int | bool | str | int  # PYI016: Duplicate union member `int`
+
+# Shouldn't emit for non-type unions.
+field7 = str | str
+
+# Should emit for strangely-bracketed unions.
+field8: int | (str | int)  # PYI016: Duplicate union member `int`
+
+# Should handle user brackets when fixing.
+field9: int | (int | str)  # PYI016: Duplicate union member `int`
+field10: (str | int) | str  # PYI016: Duplicate union member `str`
+
+# Should emit for nested unions.
+field11: dict[int | int, str]

crates/ruff/resources/test/fixtures/flake8_pyi/PYI016.pyi

@@ -0,0 +1,32 @@
+# Shouldn't affect non-union field types.
+field1: str
+
+# Should emit for duplicate field types.
+field2: str | str  # PYI016: Duplicate union member `str`
+
+# Should emit for union types in arguments.
+def func1(arg1: int | int):  # PYI016: Duplicate union member `int`
+    print(arg1)
+
+# Should emit for unions in return types.
+def func2() -> str | str:  # PYI016: Duplicate union member `str`
+    return "my string"
+
+# Should emit in longer unions, even if not directly adjacent.
+field3: str | str | int  # PYI016: Duplicate union member `str`
+field4: int | int | str  # PYI016: Duplicate union member `int`
+field5: str | int | str  # PYI016: Duplicate union member `str`
+field6: int | bool | str | int  # PYI016: Duplicate union member `int`
+
+# Shouldn't emit for non-type unions.
+field7 = str | str
+
+# Should emit for strangely-bracketed unions.
+field8: int | (str | int)  # PYI016: Duplicate union member `int`
+
+# Should handle user brackets when fixing.
+field9: int | (int | str)  # PYI016: Duplicate union member `int`
+field10: (str | int) | str  # PYI016: Duplicate union member `str`
+
+# Should emit for nested unions.
+field11: dict[int | int, str]

crates/ruff/resources/test/fixtures/flake8_pyi/PYI021.py

@@ -0,0 +1,14 @@
+"""foo"""  # OK, not in stub
+
+
+def foo():
+    """foo"""  # OK, doc strings are allowed in non-stubs
+
+
+class Bar:
+    """bar"""  # OK, doc strings are allowed in non-stubs
+
+
+def bar():
+    x = 1
+    """foo"""  # OK, not a doc string

crates/ruff/resources/test/fixtures/flake8_pyi/PYI021.pyi

@@ -0,0 +1,11 @@
+"""foo"""  # ERROR PYI021
+
+def foo():
+    """foo"""  # ERROR PYI021
+
+class Bar:
+    """bar"""  # ERROR PYI021
+
+def bar():
+    x = 1
+    """foo"""  # OK, not a doc string

crates/ruff/resources/test/fixtures/flake8_pyi/PYI033.py

@@ -0,0 +1,33 @@
+# From https://github.com/PyCQA/flake8-pyi/blob/4212bec43dbc4020a59b90e2957c9488575e57ba/tests/type_comments.pyi
+
+from collections.abc import Sequence
+from typing import TypeAlias
+
+A: TypeAlias = None  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+B: TypeAlias = None  # type: str  # And here's an extra comment about why it's that type  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+C: TypeAlias = None  #type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+D: TypeAlias = None  #      type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+E: TypeAlias = None#    type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+F: TypeAlias = None#type:int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+
+def func(
+    arg1,  # type: dict[str, int]  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+    arg2  # type: Sequence[bytes]  # And here's some more info about this arg  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+): ...
+
+class Foo:
+    Attr: TypeAlias = None  # type: set[str]  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+
+G: TypeAlias = None  # type: ignore
+H: TypeAlias = None  # type: ignore[attr-defined]
+I: TypeAlias = None  #type: ignore
+J: TypeAlias = None  #      type: ignore
+K: TypeAlias = None#    type: ignore
+L: TypeAlias = None#type:ignore
+
+# Whole line commented out  # type: int
+M: TypeAlias = None  # type: can't parse me!
+
+class Bar:
+    N: TypeAlias = None  # type: can't parse me either!
+    # This whole line is commented out and indented # type: str

crates/ruff/resources/test/fixtures/flake8_pyi/PYI033.pyi

@@ -0,0 +1,33 @@
+# From https://github.com/PyCQA/flake8-pyi/blob/4212bec43dbc4020a59b90e2957c9488575e57ba/tests/type_comments.pyi
+
+from collections.abc import Sequence
+from typing import TypeAlias
+
+A: TypeAlias = None  # type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+B: TypeAlias = None  # type: str  # And here's an extra comment about why it's that type  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+C: TypeAlias = None  #type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+D: TypeAlias = None  #      type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+E: TypeAlias = None#    type: int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+F: TypeAlias = None#type:int  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+
+def func(
+    arg1,  # type: dict[str, int]  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+    arg2  # type: Sequence[bytes]  # And here's some more info about this arg  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+): ...
+
+class Foo:
+    Attr: TypeAlias = None  # type: set[str]  # Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")
+
+G: TypeAlias = None  # type: ignore
+H: TypeAlias = None  # type: ignore[attr-defined]
+I: TypeAlias = None  #type: ignore
+J: TypeAlias = None  #      type: ignore
+K: TypeAlias = None#    type: ignore
+L: TypeAlias = None#type:ignore
+
+# Whole line commented out  # type: int
+M: TypeAlias = None  # type: can't parse me!
+
+class Bar:
+    N: TypeAlias = None  # type: can't parse me either!
+    # This whole line is commented out and indented # type: str

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT006.py

@@ -49,3 +49,18 @@ def test_list_expressions(param1, param2):
 @pytest.mark.parametrize([some_expr, "param2"], [1, 2, 3])
 def test_list_mixed_expr_literal(param1, param2):
     ...
+
+
+@pytest.mark.parametrize(("param1, " "param2, " "param3"), [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_with_parens(param1, param2, param3):
+    ...
+
+
+@pytest.mark.parametrize("param1, " "param2, " "param3", [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_no_parens(param1, param2, param3):
+    ...
+
+
+@pytest.mark.parametrize((("param1, " "param2, " "param3")), [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_with_multi_parens(param1, param2, param3):
+    ...

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT018.py

@@ -23,7 +23,7 @@ def test_error():
     """
 
     # recursive case
-    assert not (a or not (b or c))  # note that we only reduce once here
+    assert not (a or not (b or c))
     assert not (a or not (b and c))
 
     # detected, but no autofix for messages

crates/ruff/resources/test/fixtures/flake8_return/RET501.py

@@ -2,3 +2,13 @@ def x(y):
     if not y:
         return
     return None  # error
+
+
+class BaseCache:
+    def get(self, key: str) -> str | None:
+        print(f"{key} not found")
+        return None
+
+    def get(self, key: str) -> None:
+        print(f"{key} not found")
+        return None

crates/ruff/resources/test/fixtures/flake8_return/RET503.py

@@ -3,6 +3,8 @@ import os
 import posix
 from posix import abort
 import sys as std_sys
+import typing
+import typing_extensions
 import _thread
 import _winapi
 
@@ -211,6 +213,18 @@ def noreturn_sys_exit():
     std_sys.exit(0)
 
 
+def noreturn_typing_assert_never():
+    if x > 0:
+        return 1
+    typing.assert_never(0)
+
+
+def noreturn_typing_extensions_assert_never():
+    if x > 0:
+        return 1
+    typing_extensions.assert_never(0)
+
+
 def noreturn__thread_exit():
     if x > 0:
         return 1
@@ -275,3 +289,34 @@ def x(y):
             return 1
         case 1:
             print()  # error
+
+
+def foo(baz: str) -> str:
+    return baz
+
+
+def end_of_statement():
+    def example():
+        if True:
+            return ""
+
+
+    def example():
+        if True:
+            return ""
+
+
+    def example():
+        if True:
+            return ""  # type: ignore
+
+
+    def example():
+        if True:
+            return ""  ;
+
+
+    def example():
+        if True:
+            return "" \
+                ;  # type: ignore

crates/ruff/resources/test/fixtures/flake8_return/RET504.py

@@ -3,23 +3,7 @@
 ###
 def x():
     a = 1
-    return a  # error
-
-
-def x():
-    a = 1
-    print(a)
-    a = 2
-    return a  # error
-
-
-def x():
-    a = 1
-    if True:
-        return a  # error
-    a = 2
-    print(a)
-    return a
+    return a  # RET504
 
 
 # Can be refactored false positives
@@ -165,44 +149,6 @@ def my_func():
     return foo
 
 
-# Refactored incorrect false positives
-# See test cases above marked: "Can be refactored false positives"
-# https://github.com/afonasev/flake8-return/issues/47#issuecomment-1122571066
-def get_bar_if_exists(obj):
-    if hasattr(obj, "bar"):
-        return str(obj.bar)
-    return ""
-
-
-# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
-def x():
-    formatted = _USER_AGENT_FORMATTER.format(format_string, **values)
-    # clean up after any blank components
-    return formatted.replace("()", "").replace("  ", " ").strip()
-
-
-# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
-def user_agent_username(username=None):
-
-    if not username:
-        return ""
-
-    username = username.replace(" ", "_")  # Avoid spaces or %20.
-    try:
-        username.encode("ascii")  # just test,
-        # but not actually use it
-    except UnicodeEncodeError:
-        username = quote(username.encode("utf-8"))
-    else:
-        # % is legal in the default $wgLegalTitleChars
-        # This is so that ops know the real pywikibot will not
-        # allow a useragent in the username to allow through a
-        # hand-coded percent-encoded value.
-        if "%" in username:
-            username = quote(username)
-    return username
-
-
 # https://github.com/afonasev/flake8-return/issues/116#issue-1367575481
 def no_exception_loop():
     success = False
@@ -260,3 +206,69 @@ def nonlocal_assignment():
         nonlocal X
         X = 1
         return X
+
+
+def decorator() -> Flask:
+    app = Flask(__name__)
+
+    @app.route("/hello")
+    def hello() -> str:
+        """Hello endpoint."""
+        return "Hello, World!"
+
+    return app
+
+
+def default():
+    y = 1
+
+    def f(x=y) -> X:
+        return x
+
+    return y
+
+
+# Multiple assignment
+def get_queryset(option_1, option_2):
+    queryset: Any = None
+    queryset = queryset.filter(a=1)
+    if option_1:
+        queryset = queryset.annotate(b=Value(2))
+    if option_2:
+        queryset = queryset.filter(c=3)
+    return queryset
+
+
+def get_queryset():
+    queryset = Model.filter(a=1)
+    queryset = queryset.filter(c=3)
+    return queryset
+
+
+def get_queryset():
+    queryset = Model.filter(a=1)
+    return queryset  # RET504
+
+
+# Function arguments
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return val
+    val = val.strip().lower()
+    if val in ("1", "true", "yes"):
+        return True
+
+    return False
+
+
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return val
+    val = 1
+    return val  # RET504
+
+
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return some_obj
+    return val

crates/ruff/resources/test/fixtures/flake8_simplify/SIM101.py

@@ -16,15 +16,26 @@ if isinstance(a, int) or isinstance(b, bool) or isinstance(a, float):  # SIM101
 if (isinstance(a, int) or isinstance(a, float)) and isinstance(b, bool):  # SIM101
     pass
 
+if isinstance(a.b, int) or isinstance(a.b, float):  # SIM101
+    pass
+
+if isinstance(a(), int) or isinstance(a(), float):  # SIM101
+    pass
+
 if isinstance(a, int) and isinstance(b, bool) or isinstance(a, float):
     pass
 
 if isinstance(a, bool) or isinstance(b, str):
     pass
 
+if isinstance(a, int) or isinstance(a.b, float):
+    pass
+
+
 def f():
     # OK
     def isinstance(a, b):
         return False
+
     if isinstance(a, int) or isinstance(a, float):
         pass

crates/ruff/resources/test/fixtures/flake8_simplify/SIM102.py

@@ -46,10 +46,10 @@ if a:
     if b:
         c
 
-while True:
+while x > 0:
     # SIM102
-    if True:
-        if True:
+    if y > 0:
+        if z > 0:
             """this
 is valid"""
 
@@ -64,8 +64,8 @@ is valid"""
 
 
 # SIM102
-if True:
-    if True:
+if x > 0:
+    if y > 0:
         """this
 is valid"""
 
@@ -78,7 +78,7 @@ is valid"""
         ("so is"
 "this for some reason")
 
-while True:
+while x > 0:
     # SIM102
     if node.module:
         if node.module == "multiprocessing" or node.module.startswith(
@@ -129,3 +129,15 @@ if a:
         print("baz")
 else:
     print("bar")
+
+
+# OK
+if False:
+    if a:
+        pass
+
+
+# OK
+if True:
+    if a:
+        pass

crates/ruff/resources/test/fixtures/flake8_simplify/SIM105.py

@@ -59,3 +59,15 @@ def bar():
         return foo()
     except ValueError:
         pass
+
+def with_ellipsis():
+    try:
+        foo()
+    except ValueError:
+        ...
+
+def with_ellipsis_and_return():
+    try:
+        return foo()
+    except ValueError:
+        ...

crates/ruff/resources/test/fixtures/flake8_simplify/SIM112.py

@@ -9,6 +9,17 @@ os.environ.get('foo', 'bar')
 
 os.getenv('foo')
 
+env = os.environ.get('foo')
+
+env = os.environ['foo']
+
+if env := os.environ.get('foo'):
+    pass
+
+if env := os.environ['foo']:
+    pass
+
+
 # Good
 os.environ['FOO']
 
@@ -17,3 +28,13 @@ os.environ.get('FOO')
 os.environ.get('FOO', 'bar')
 
 os.getenv('FOO')
+
+env = os.getenv('FOO')
+
+if env := os.getenv('FOO'):
+    pass
+
+env = os.environ['FOO']
+
+if env := os.environ['FOO']:
+    pass

crates/ruff/resources/test/fixtures/flake8_simplify/SIM116.py

@@ -74,3 +74,13 @@ elif b == b"two":
     return 2
 elif a == b"three":
     return 3
+
+# SIM116
+if func_name == "create":
+    return "A"
+elif func_name == "modify":
+    return "M"
+elif func_name == "remove":
+    return "D"
+elif func_name == "move":
+    return "MV"

crates/ruff/resources/test/fixtures/flake8_simplify/SIM118.py

@@ -20,3 +20,5 @@ for key in list(obj.keys()):
 {k: k for k in obj.keys()}  # SIM118
 
 (k for k in obj.keys())  # SIM118
+
+key in (obj or {}).keys()  # SIM118

crates/ruff/resources/test/fixtures/flake8_simplify/SIM222.py

@@ -1,10 +1,10 @@
-if a or True:  # SIM223
+if a or True:  # SIM222
     pass
 
-if (a or b) or True:  # SIM223
+if (a or b) or True:  # SIM222
     pass
 
-if a or (b or True):  # SIM223
+if a or (b or True):  # SIM222
     pass
 
 if a and True:  # OK
@@ -16,3 +16,139 @@ if True:  # OK
 
 def validate(self, value):
     return json.loads(value) or True  # OK
+
+
+if a or f() or b or g() or True:  # OK
+    pass
+
+if a or f() or True or g() or b:  # SIM222
+    pass
+
+if True or f() or a or g() or b:  # SIM222
+    pass
+
+if a or True or f() or b or g():  # SIM222
+    pass
+
+
+if a and f() and b and g() and False:  # OK
+    pass
+
+if a and f() and False and g() and b:  # OK
+    pass
+
+if False and f() and a and g() and b:  # OK
+    pass
+
+if a and False and f() and b and g():  # OK
+    pass
+
+
+a or "" or True  # SIM222
+
+a or "foo" or True or "bar"  # SIM222
+
+a or 0 or True  # SIM222
+
+a or 1 or True or 2  # SIM222
+
+a or 0.0 or True  # SIM222
+
+a or 0.1 or True or 0.2  # SIM222
+
+a or [] or True  # SIM222
+
+a or list([]) or True  # SIM222
+
+a or [1] or True or [2]  # SIM222
+
+a or list([1]) or True or list([2])  # SIM222
+
+a or {} or True  # SIM222
+
+a or dict() or True  # SIM222
+
+a or {1: 1} or True or {2: 2}  # SIM222
+
+a or dict({1: 1}) or True or dict({2: 2})  # SIM222
+
+a or set() or True  # SIM222
+
+a or set(set()) or True  # SIM222
+
+a or {1} or True or {2}  # SIM222
+
+a or set({1}) or True or set({2})  # SIM222
+
+a or () or True  # SIM222
+
+a or tuple(()) or True  # SIM222
+
+a or (1,) or True or (2,)  # SIM222
+
+a or tuple((1,)) or True or tuple((2,))  # SIM222
+
+a or frozenset() or True  # SIM222
+
+a or frozenset(frozenset()) or True  # SIM222
+
+a or frozenset({1}) or True or frozenset({2})  # SIM222
+
+a or frozenset(frozenset({1})) or True or frozenset(frozenset({2}))  # SIM222
+
+
+# Inside test `a` is simplified.
+
+bool(a or [1] or True or [2])  # SIM222
+
+assert a or [1] or True or [2]  # SIM222
+
+if (a or [1] or True or [2]) and (a or [1] or True or [2]):  # SIM222
+    pass
+
+0 if a or [1] or True or [2] else 1  # SIM222
+
+while a or [1] or True or [2]:  # SIM222
+    pass
+
+[
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+]
+
+{
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+}
+
+{
+    0: 0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+}
+
+(
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+)
+
+# Outside test `a` is not simplified.
+
+a or [1] or True or [2]  # SIM222
+
+if (a or [1] or True or [2]) == (a or [1]):  # SIM222
+    pass
+
+if f(a or [1] or True or [2]):  # SIM222
+    pass

crates/ruff/resources/test/fixtures/flake8_simplify/SIM223.py

@@ -12,3 +12,138 @@ if a or False:
 
 if False:
     pass
+
+if a and f() and b and g() and False:  # OK
+    pass
+
+if a and f() and False and g() and b:  # SIM223
+    pass
+
+if False and f() and a and g() and b:  # SIM223
+    pass
+
+if a and False and f() and b and g():  # SIM223
+    pass
+
+
+if a or f() or b or g() or True:  # OK
+    pass
+
+if a or f() or True or g() or b:  # OK
+    pass
+
+if True or f() or a or g() or b:  # OK
+    pass
+
+if a or True or f() or b or g():  # OK
+    pass
+
+
+a and "" and False  # SIM223
+
+a and "foo" and False and "bar"  # SIM223
+
+a and 0 and False  # SIM223
+
+a and 1 and False and 2  # SIM223
+
+a and 0.0 and False  # SIM223
+
+a and 0.1 and False and 0.2  # SIM223
+
+a and [] and False  # SIM223
+
+a and list([]) and False  # SIM223
+
+a and [1] and False and [2]  # SIM223
+
+a and list([1]) and False and list([2])  # SIM223
+
+a and {} and False  # SIM223
+
+a and dict() and False  # SIM223
+
+a and {1: 1} and False and {2: 2}  # SIM223
+
+a and dict({1: 1}) and False and dict({2: 2})  # SIM223
+
+a and set() and False  # SIM223
+
+a and set(set()) and False  # SIM223
+
+a and {1} and False and {2}  # SIM223
+
+a and set({1}) and False and set({2})  # SIM223
+
+a and () and False  # SIM222
+
+a and tuple(()) and False  # SIM222
+
+a and (1,) and False and (2,)  # SIM222
+
+a and tuple((1,)) and False and tuple((2,))  # SIM222
+
+a and frozenset() and False  # SIM222
+
+a and frozenset(frozenset()) and False  # SIM222
+
+a and frozenset({1}) and False and frozenset({2})  # SIM222
+
+a and frozenset(frozenset({1})) and False and frozenset(frozenset({2}))  # SIM222
+
+
+# Inside test `a` is simplified.
+
+bool(a and [] and False and [])  # SIM223
+
+assert a and [] and False and []  # SIM223
+
+if (a and [] and False and []) or (a and [] and False and []):  # SIM223
+    pass
+
+0 if a and [] and False and [] else 1  # SIM222
+
+while a and [] and False and []:  # SIM223
+    pass
+
+[
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+]
+
+{
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+}
+
+{
+    0: 0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+}
+
+(
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+)
+
+# Outside test `a` is not simplified.
+
+a and [] and False and []  # SIM223
+
+if (a and [] and False and []) == (a and []):  # SIM223
+    pass
+
+if f(a and [] and False and []):  # SIM223
+    pass