Bump version to 0.0.167

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.159
+    rev: v0.0.167
     hooks:
       - id: ruff
 

CONTRIBUTING.md

@@ -105,6 +105,8 @@ You may also want to add the new configuration option to the `flake8-to-ruff` to
 responsible for converting `flake8` configuration files to Ruff's TOML format. This logic
 lives in `flake8_to_ruff/src/converter.rs`.
 
+To update the documentation for supported configuration options, run `cargo dev generate-options`.
+
 ## Release process
 
 As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub

Cargo.lock

@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.159-dev.0"
+version = "0.0.167-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.159"
+version = "0.0.167"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1855,6 +1855,7 @@ dependencies = [
  "rayon",
  "regex",
  "ropey",
+ "ruff_macros",
  "rustc-hash",
  "rustpython-ast",
  "rustpython-common",
@@ -1873,7 +1874,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.159"
+version = "0.0.167"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1889,6 +1890,16 @@ dependencies = [
  "strum_macros",
 ]
 
+[[package]]
+name = "ruff_macros"
+version = "0.0.161"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "textwrap",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.159"
+version = "0.0.167"
 edition = "2021"
 rust-version = "1.65.0"
 
@@ -41,6 +41,7 @@ quick-junit = { version = "0.3.2" }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
+ruff_macros = { version = "0.0.161", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }

create_plugin.sh

@@ -1,11 +0,0 @@
-set -euxo pipefail
-
-NAME=$1
-
-mkdir -p src/$1
-mkdir -p resources/test/fixtures/$1
-touch src/$1/mod.rs
-
-sed -i "" "s/mod flake8_print;/mod flake8_print; mod flake8_return;/g" src/lib.rs
-sed -i "" "s|// flake8-print|// flake8-return\n// flake8-print|g" src/checks.rs
-

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.159"
+version = "0.0.167"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.159"
+version = "0.0.167"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.159-dev.0"
+version = "0.0.167-dev.0"
 edition = "2021"
 
 [lib]

flake8_to_ruff/src/converter.rs

@@ -243,6 +243,7 @@ mod tests {
     fn it_converts_empty() -> Result<()> {
         let actual = convert(&HashMap::from([]), None)?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -269,6 +270,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -286,6 +288,7 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -312,6 +315,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -329,6 +333,7 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -355,6 +360,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -372,6 +378,7 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -398,6 +405,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -415,6 +423,7 @@ mod tests {
             Some(vec![]),
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -446,6 +455,7 @@ mod tests {
                 avoid_escape: None,
             }),
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -466,6 +476,7 @@ mod tests {
             Some(vec![Plugin::Flake8Docstrings]),
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -527,6 +538,7 @@ mod tests {
             flake8_bugbear: None,
             flake8_quotes: None,
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -544,6 +556,7 @@ mod tests {
             None,
         )?;
         let expected = Pyproject::new(Options {
+            allowed_confusables: None,
             dummy_variable_rgx: None,
             exclude: None,
             extend_exclude: None,
@@ -576,6 +589,7 @@ mod tests {
                 avoid_escape: None,
             }),
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,

resources/test/fixtures/flake8_annotations/allow_overload.py

@@ -0,0 +1,49 @@
+from typing import overload
+
+
+@overload
+def foo(i: int) -> "int":
+    ...
+
+
+@overload
+def foo(i: "str") -> "str":
+    ...
+
+
+def foo(i):
+    return i
+
+
+@overload
+def bar(i: int) -> "int":
+    ...
+
+
+@overload
+def bar(i: "str") -> "str":
+    ...
+
+
+class X:
+    def bar(i):
+        return i
+
+
+# TODO(charlie): This third case should raise an error (as in Mypy), because we have a
+# statement between the interfaces and implementation.
+@overload
+def baz(i: int) -> "int":
+    ...
+
+
+@overload
+def baz(i: "str") -> "str":
+    ...
+
+
+x = 1
+
+
+def baz(i):
+    return i

resources/test/fixtures/flake8_blind_except/BLE.py

@@ -53,3 +53,11 @@ try:
         raise e
 except Exception:
     pass
+
+
+try:
+    pass
+except Exception as e:
+    raise bad
+except BaseException:
+    pass

resources/test/fixtures/flake8_bugbear/B905.py

@@ -0,0 +1,10 @@
+zip()
+zip(range(3))
+zip("a", "b")
+zip("a", "b", *zip("c"))
+zip(zip("a"), strict=False)
+zip(zip("a", strict=True))
+
+zip(range(3), strict=True)
+zip("a", "b", strict=False)
+zip("a", "b", "c", strict=True)

resources/test/fixtures/flake8_import_conventions/custom.py

@@ -0,0 +1,25 @@
+import math  # not checked
+
+import altair  # unconventional
+import dask.array  # unconventional
+import dask.dataframe  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import dask.array as darray  # unconventional
+import dask.dataframe as ddf  # unconventional
+import numpy as nmp  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import dask.array as da  # conventional
+import dask.dataframe as dd  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/defaults.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as nmp  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/override_default.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # unconventional
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as np  # unconventional
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as nmp  # conventional
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/flake8_import_conventions/remove_default.py

@@ -0,0 +1,19 @@
+import math  # not checked
+
+import altair  # unconventional
+import matplotlib.pyplot  # unconventional
+import numpy  # not checked
+import pandas  # unconventional
+import seaborn  # unconventional
+
+import altair as altr  # unconventional
+import matplotlib.pyplot as plot  # unconventional
+import numpy as nmp  # not checked
+import pandas as pdas  # unconventional
+import seaborn as sbrn  # unconventional
+
+import altair as alt  # conventional
+import matplotlib.pyplot as plt  # conventional
+import numpy as np  # not checked
+import pandas as pd  # conventional
+import seaborn as sns  # conventional

resources/test/fixtures/isort/insert_empty_lines.py

@@ -0,0 +1,41 @@
+import a
+import b
+x = 1
+import os
+import sys
+def f():
+    pass
+if True:
+    x = 1
+    import collections
+    import typing
+class X: pass
+y = 1
+import os
+import sys
+"""Docstring"""
+
+if True:
+    import os
+
+
+def f():
+    pass
+
+
+if True:
+    import os
+def f():
+    pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    class X: pass
+
+if True:
+    x = 1
+    import collections
+    import typing
+    def f(): pass

resources/test/fixtures/isort/no_wrap_star.py

@@ -0,0 +1 @@
+from .subscription import * # type: ignore  # some very long comment explaining why this needs a type ignore

resources/test/fixtures/isort/preserve_import_star.py

@@ -0,0 +1,6 @@
+from some_other_module import some_class
+from some_other_module import *
+# Above
+from some_module import some_class  # Aside
+# Above
+from some_module import *  # Aside

resources/test/fixtures/isort/skip_file.py

@@ -0,0 +1,10 @@
+# isort: skip_file
+import e
+import f
+
+# isort: split
+
+import a
+import b
+import c
+import d

resources/test/fixtures/isort/split.py

@@ -0,0 +1,9 @@
+import e
+import f
+
+# isort: split
+
+import a
+import b
+import c
+import d

resources/test/fixtures/pydocstyle/D.py

@@ -571,3 +571,11 @@ def multiline_trailing_and_leading_space():
     """
 
     pass
+
+
+@expect('D210: No whitespaces allowed surrounding docstring text')
+@expect("D400: First line should end with a period (not '\"')")
+@expect("D415: First line should end with a period, question mark, "
+        "or exclamation point (not '\"')")
+def endswith_quote():
+    """Whitespace at the end, but also a quote" """

resources/test/fixtures/pydocstyle/D400.py

@@ -0,0 +1,73 @@
+def f():
+    "Here's a line without a period"
+    ...
+
+
+def f():
+    """Here's a line without a period"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line
+    """
+    ...
+
+
+def f():
+    """Here's a line without a period"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line"""
+    ...
+
+
+def f():
+    """
+    Here's a line without a period,
+    but here's the next line with trailing space """
+    ...
+
+
+
+def f():
+    r"Here's a line without a period"
+    ...
+
+
+def f():
+    r"""Here's a line without a period"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line
+    """
+    ...
+
+
+def f():
+    r"""Here's a line without a period"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line"""
+    ...
+
+
+def f():
+    r"""
+    Here's a line without a period,
+    but here's the next line with trailing space """
+    ...

resources/test/fixtures/pyflakes/F841_0.py

@@ -65,3 +65,8 @@ def f7():
 
     with connect() as (connection, cursor):
         cursor.execute("SELECT * FROM users")
+
+
+def f8():
+    with open("file") as f, open("") as ((a, b)):
+        print("hello")

resources/test/fixtures/pyflakes/F841_1.py

@@ -0,0 +1,24 @@
+def f(tup):
+    x, y = tup  # this does NOT trigger F841
+
+
+def f():
+    x, y = 1, 2  # this triggers F841 as it's just a simple assignment where unpacking isn't needed
+
+
+def f():
+    (x, y) = coords = 1, 2  # this does NOT trigger F841
+    if x > 1:
+        print(coords)
+
+
+def f():
+    (x, y) = coords = 1, 2  # this triggers F841 on coords
+
+
+def f():
+    coords = (x, y) = 1, 2  # this triggers F841 on coords
+
+
+def f():
+    (a, b) = (x, y) = 1, 2  # this triggers F841 on everything

resources/test/fixtures/pyproject.toml

@@ -1,4 +1,5 @@
 [tool.ruff]
+allowed-confusables = ["−", "ρ", "∗"]
 line-length = 88
 extend-exclude = [
   "excluded_file.py",
@@ -35,13 +36,14 @@ ignore-names = [
   "longMessage",
   "maxDiff",
 ]
-classmethod-decorators = [
-  "classmethod",
-  "pydantic.validator",
-]
-staticmethod-decorators = [
-  "staticmethod",
-]
+classmethod-decorators = ["classmethod", "pydantic.validator"]
+staticmethod-decorators = ["staticmethod"]
 
 [tool.ruff.flake8-tidy-imports]
 ban-relative-imports = "parents"
+
+[tool.ruff.flake8-import-conventions.aliases]
+pandas = "pd"
+
+[tool.ruff.flake8-import-conventions.extend-aliases]
+"dask.dataframe" = "dd"

resources/test/fixtures/ruff/RUF001.py

@@ -1,7 +0,0 @@
-x = "𝐁ad string"
-
-
-def f():
-    """Here's a docstring with an unusual parenthesis: ）"""
-    # And here's a comment with an unusual punctuation mark: ᜵
-    ...

resources/test/fixtures/ruff/RUF002.py

@@ -1,7 +0,0 @@
-x = "𝐁ad string"
-
-
-def f():
-    """Here's a docstring with an unusual parenthesis: ）"""
-    # And here's a comment with an unusual punctuation mark: ᜵
-    ...

resources/test/fixtures/ruff/confusables.py

@@ -1,7 +1,14 @@
 x = "𝐁ad string"
+y = "−"
 
 
 def f():
     """Here's a docstring with an unusual parenthesis: ）"""
     # And here's a comment with an unusual punctuation mark: ᜵
     ...
+
+
+def g():
+    """Here's a docstring with a greek rho: ρ"""
+    # And here's a comment with a greek alpha: ∗
+    ...

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.159"
+version = "0.0.167"
 edition = "2021"
 
 [dependencies]

ruff_dev/src/generate_check_code_prefix.rs

@@ -76,6 +76,7 @@ pub fn main(cli: &Cli) -> Result<()> {
         .new_enum("CheckCodePrefix")
         .vis("pub")
         .derive("EnumString")
+        .derive("AsRefStr")
         .derive("Debug")
         .derive("PartialEq")
         .derive("Eq")
@@ -170,9 +171,9 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push_str("use colored::Colorize;");
     output.push('\n');
-    output.push_str("use serde::{{Serialize, Deserialize}};");
+    output.push_str("use serde::{Deserialize, Serialize};");
     output.push('\n');
-    output.push_str("use strum_macros::EnumString;");
+    output.push_str("use strum_macros::{AsRefStr, EnumString};");
     output.push('\n');
     output.push('\n');
     output.push_str("use crate::checks::CheckCode;");

ruff_dev/src/generate_options.rs

@@ -0,0 +1,125 @@
+//! Generate a Markdown-compatible listing of configuration options.
+
+use std::fs;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Args;
+use itertools::Itertools;
+use ruff::settings::options::Options;
+use ruff::settings::options_base::{ConfigurationOptions, OptionEntry, OptionField};
+
+const BEGIN_PRAGMA: &str = "<!-- Begin auto-generated options sections. -->";
+const END_PRAGMA: &str = "<!-- End auto-generated options sections. -->";
+
+#[derive(Args)]
+pub struct Cli {
+    /// Write the generated table to stdout (rather than to `README.md`).
+    #[arg(long)]
+    dry_run: bool,
+}
+
+fn emit_field(output: &mut String, field: &OptionField, group_name: Option<&str>) {
+    output.push_str(&format!("#### [`{0}`](#{0})\n", field.name));
+    output.push('\n');
+    output.push_str(field.doc);
+    output.push_str("\n\n");
+    output.push_str(&format!("**Default value**: `{}`\n", field.default));
+    output.push('\n');
+    output.push_str(&format!("**Type**: `{}`\n", field.value_type));
+    output.push('\n');
+    output.push_str(&format!(
+        "**Example usage**:\n\n```toml\n[tool.ruff{}]\n{}\n```\n",
+        if group_name.is_some() {
+            format!(".{}", group_name.unwrap())
+        } else {
+            String::new()
+        },
+        field.example
+    ));
+    output.push('\n');
+}
+
+pub fn main(cli: &Cli) -> Result<()> {
+    let mut output = String::new();
+
+    // Generate all the top-level fields.
+    for field in Options::get_available_options()
+        .into_iter()
+        .filter_map(|entry| {
+            if let OptionEntry::Field(field) = entry {
+                Some(field)
+            } else {
+                None
+            }
+        })
+        .sorted_by_key(|field| field.name)
+    {
+        emit_field(&mut output, &field, None);
+        output.push_str("---\n\n");
+    }
+
+    // Generate all the sub-groups.
+    for group in Options::get_available_options()
+        .into_iter()
+        .filter_map(|entry| {
+            if let OptionEntry::Group(group) = entry {
+                Some(group)
+            } else {
+                None
+            }
+        })
+        .sorted_by_key(|group| group.name)
+    {
+        output.push_str(&format!("### `{}`\n", group.name));
+        output.push('\n');
+        for field in group
+            .fields
+            .iter()
+            .filter_map(|entry| {
+                if let OptionEntry::Field(field) = entry {
+                    Some(field)
+                } else {
+                    None
+                }
+            })
+            .sorted_by_key(|field| field.name)
+        {
+            emit_field(&mut output, field, Some(group.name));
+            output.push_str("---\n\n");
+        }
+    }
+
+    if cli.dry_run {
+        print!("{output}");
+    } else {
+        // Read the existing file.
+        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .expect("Failed to find root directory")
+            .join("README.md");
+        let existing = fs::read_to_string(&file)?;
+
+        // Extract the prefix.
+        let index = existing
+            .find(BEGIN_PRAGMA)
+            .expect("Unable to find begin pragma");
+        let prefix = &existing[..index + BEGIN_PRAGMA.len()];
+
+        // Extract the suffix.
+        let index = existing
+            .find(END_PRAGMA)
+            .expect("Unable to find end pragma");
+        let suffix = &existing[index..];
+
+        // Write the prefix, new contents, and suffix.
+        let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
+        write!(f, "{prefix}\n\n")?;
+        write!(f, "{output}")?;
+        write!(f, "{suffix}")?;
+    }
+
+    Ok(())
+}

ruff_dev/src/generate_rules_table.rs

@@ -7,11 +7,15 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Args;
+use itertools::Itertools;
 use ruff::checks::{CheckCategory, CheckCode};
 use strum::IntoEnumIterator;
 
-const BEGIN_PRAGMA: &str = "<!-- Begin auto-generated sections. -->";
-const END_PRAGMA: &str = "<!-- End auto-generated sections. -->";
+const TABLE_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated sections. -->";
+const TABLE_END_PRAGMA: &str = "<!-- End auto-generated sections. -->";
+
+const TOC_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated table of contents. -->";
+const TOC_END_PRAGMA: &str = "<!-- End auto-generated table of contents. -->";
 
 #[derive(Args)]
 pub struct Cli {
@@ -22,73 +26,91 @@ pub struct Cli {
 
 pub fn main(cli: &Cli) -> Result<()> {
     // Generate the table string.
-    let mut output = String::new();
+    let mut table_out = String::new();
+    let mut toc_out = String::new();
     for check_category in CheckCategory::iter() {
-        output.push_str(&format!("### {}", check_category.title()));
-        output.push('\n');
-        output.push('\n');
+        let codes_csv: String = check_category.codes().iter().map(AsRef::as_ref).join(", ");
+        table_out.push_str(&format!("### {} ({codes_csv})", check_category.title()));
+        table_out.push('\n');
+        table_out.push('\n');
+
+        toc_out.push_str(&format!(
+            "   1. [{} ({})](#{}-{})\n",
+            check_category.title(),
+            codes_csv,
+            check_category.title().to_lowercase().replace(' ', "-"),
+            codes_csv.to_lowercase().replace(',', "-").replace(' ', "")
+        ));
 
         if let Some((url, platform)) = check_category.url() {
-            output.push_str(&format!(
+            table_out.push_str(&format!(
                 "For more, see [{}]({}) on {}.",
                 check_category.title(),
                 url,
                 platform
             ));
-            output.push('\n');
-            output.push('\n');
+            table_out.push('\n');
+            table_out.push('\n');
         }
 
-        output.push_str("| Code | Name | Message | Fix |");
-        output.push('\n');
-        output.push_str("| ---- | ---- | ------- | --- |");
-        output.push('\n');
+        table_out.push_str("| Code | Name | Message | Fix |");
+        table_out.push('\n');
+        table_out.push_str("| ---- | ---- | ------- | --- |");
+        table_out.push('\n');
 
         for check_code in CheckCode::iter() {
             if check_code.category() == check_category {
                 let check_kind = check_code.kind();
                 let fix_token = if check_kind.fixable() { "🛠" } else { "" };
-                output.push_str(&format!(
+                table_out.push_str(&format!(
                     "| {} | {} | {} | {} |",
                     check_kind.code().as_ref(),
                     check_kind.as_ref(),
                     check_kind.summary().replace('|', r"\|"),
                     fix_token
                 ));
-                output.push('\n');
+                table_out.push('\n');
             }
         }
-        output.push('\n');
+        table_out.push('\n');
     }
 
     if cli.dry_run {
-        print!("{output}");
+        print!("Table of Contents: {toc_out}\n Rules Tables: {table_out}");
     } else {
-        // Read the existing file.
-        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .expect("Failed to find root directory")
-            .join("README.md");
-        let existing = fs::read_to_string(&file)?;
-
-        // Extract the prefix.
-        let index = existing
-            .find(BEGIN_PRAGMA)
-            .expect("Unable to find begin pragma");
-        let prefix = &existing[..index + BEGIN_PRAGMA.len()];
-
-        // Extract the suffix.
-        let index = existing
-            .find(END_PRAGMA)
-            .expect("Unable to find end pragma");
-        let suffix = &existing[index..];
-
-        // Write the prefix, new contents, and suffix.
-        let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
-        write!(f, "{prefix}\n\n")?;
-        write!(f, "{output}")?;
-        write!(f, "{suffix}")?;
+        // Extra newline in the markdown numbered list looks weird
+        replace_readme_section(toc_out.trim_end(), TOC_BEGIN_PRAGMA, TOC_END_PRAGMA)?;
+        replace_readme_section(&table_out, TABLE_BEGIN_PRAGMA, TABLE_END_PRAGMA)?;
     }
 
     Ok(())
 }
+
+fn replace_readme_section(content: &str, begin_pragma: &str, end_pragma: &str) -> Result<()> {
+    // Read the existing file.
+    let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("Failed to find root directory")
+        .join("README.md");
+    let existing = fs::read_to_string(&file)?;
+
+    // Extract the prefix.
+    let index = existing
+        .find(begin_pragma)
+        .expect("Unable to find begin pragma");
+    let prefix = &existing[..index + begin_pragma.len()];
+
+    // Extract the suffix.
+    let index = existing
+        .find(end_pragma)
+        .expect("Unable to find end pragma");
+    let suffix = &existing[index..];
+
+    // Write the prefix, new contents, and suffix.
+    let mut f = OpenOptions::new().write(true).truncate(true).open(&file)?;
+    writeln!(f, "{prefix}")?;
+    write!(f, "{content}")?;
+    write!(f, "{suffix}")?;
+
+    Ok(())
+}

ruff_dev/src/lib.rs

@@ -12,6 +12,7 @@
 )]
 
 pub mod generate_check_code_prefix;
+pub mod generate_options;
 pub mod generate_rules_table;
 pub mod generate_source_code;
 pub mod print_ast;

ruff_dev/src/main.rs

@@ -14,8 +14,8 @@
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 use ruff_dev::{
-    generate_check_code_prefix, generate_rules_table, generate_source_code, print_ast, print_cst,
-    print_tokens,
+    generate_check_code_prefix, generate_options, generate_rules_table, generate_source_code,
+    print_ast, print_cst, print_tokens,
 };
 
 #[derive(Parser)]
@@ -32,6 +32,8 @@ enum Commands {
     GenerateCheckCodePrefix(generate_check_code_prefix::Cli),
     /// Generate a Markdown-compatible table of supported lint rules.
     GenerateRulesTable(generate_rules_table::Cli),
+    /// Generate a Markdown-compatible listing of configuration options.
+    GenerateOptions(generate_options::Cli),
     /// Run round-trip source code generation on a given Python file.
     GenerateSourceCode(generate_source_code::Cli),
     /// Print the AST for a given Python file.
@@ -48,6 +50,7 @@ fn main() -> Result<()> {
         Commands::GenerateCheckCodePrefix(args) => generate_check_code_prefix::main(args)?,
         Commands::GenerateRulesTable(args) => generate_rules_table::main(args)?,
         Commands::GenerateSourceCode(args) => generate_source_code::main(args)?,
+        Commands::GenerateOptions(args) => generate_options::main(args)?,
         Commands::PrintAST(args) => print_ast::main(args)?,
         Commands::PrintCST(args) => print_cst::main(args)?,
         Commands::PrintTokens(args) => print_tokens::main(args)?,

ruff_macros/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ruff_macros"
+version = "0.0.161"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = { version = "1.0.47" }
+quote = { version = "1.0.21" }
+syn = { version = "1.0.103", features = ["derive", "parsing"] }
+textwrap = { version = "0.16.0" }

ruff_macros/src/lib.rs

@@ -0,0 +1,177 @@
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::collapsible_if,
+    clippy::implicit_hasher,
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::too_many_lines
+)]
+
+use quote::{quote, quote_spanned};
+use syn::parse::{Parse, ParseStream};
+use syn::token::Comma;
+use syn::{
+    parse_macro_input, AngleBracketedGenericArguments, Attribute, Data, DataStruct, DeriveInput,
+    Field, Fields, Lit, LitStr, Path, PathArguments, PathSegment, Token, Type, TypePath,
+};
+
+#[proc_macro_derive(ConfigurationOptions, attributes(option, option_group))]
+pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    derive_impl(input)
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
+fn derive_impl(input: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
+    let DeriveInput { ident, data, .. } = input;
+
+    match data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => {
+            let mut output = vec![];
+
+            for field in fields.named.iter() {
+                if let Some(attr) = field.attrs.iter().find(|a| a.path.is_ident("option")) {
+                    output.push(handle_option(field, attr)?);
+                };
+
+                if field.attrs.iter().any(|a| a.path.is_ident("option_group")) {
+                    output.push(handle_option_group(field)?);
+                };
+            }
+
+            Ok(quote! {
+              use crate::settings::options_base::{OptionEntry, OptionField, OptionGroup, ConfigurationOptions};
+
+              #[automatically_derived]
+              impl ConfigurationOptions for #ident {
+                  fn get_available_options() -> Vec<OptionEntry> {
+                      vec![#(#output),*]
+                  }
+              }
+            })
+        }
+        _ => Err(syn::Error::new(
+            ident.span(),
+            "Can only derive ConfigurationOptions from structs with named fields.",
+        )),
+    }
+}
+
+/// For a field with type `Option<Foobar>` where `Foobar` itself is a struct
+/// deriving `ConfigurationOptions`, create code that calls retrieves options
+/// from that group: `Foobar::get_available_options()`
+fn handle_option_group(field: &Field) -> syn::Result<proc_macro2::TokenStream> {
+    // unwrap is safe because we're only going over named fields
+    let ident = field.ident.as_ref().unwrap();
+
+    match &field.ty {
+        Type::Path(TypePath {
+            path: Path { segments, .. },
+            ..
+        }) => match segments.first() {
+            Some(PathSegment {
+                ident: type_ident,
+                arguments:
+                    PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }),
+                ..
+            }) if type_ident == "Option" => {
+                let path = &args[0];
+                let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span());
+
+                Ok(quote_spanned!(
+                    ident.span() => OptionEntry::Group(OptionGroup {
+                        name: #kebab_name,
+                        fields: #path::get_available_options(),
+                    })
+                ))
+            }
+            _ => Err(syn::Error::new(
+                ident.span(),
+                "Expected `Option<_>`  as type.",
+            )),
+        },
+        _ => Err(syn::Error::new(ident.span(), "Expected type.")),
+    }
+}
+
+/// Parse an `#[option(doc="...", default="...", value_type="...",
+/// example="...")]` attribute and return data in the form of an `OptionField`.
+fn handle_option(field: &Field, attr: &Attribute) -> syn::Result<proc_macro2::TokenStream> {
+    // unwrap is safe because we're only going over named fields
+    let ident = field.ident.as_ref().unwrap();
+
+    let FieldAttributes {
+        doc,
+        default,
+        value_type,
+        example,
+    } = attr.parse_args::<FieldAttributes>()?;
+    let kebab_name = LitStr::new(&ident.to_string().replace('_', "-"), ident.span());
+
+    Ok(quote_spanned!(
+        ident.span() => OptionEntry::Field(OptionField {
+            name: #kebab_name,
+            doc: &#doc,
+            default: &#default,
+            value_type: &#value_type,
+            example: &#example,
+        })
+    ))
+}
+
+#[derive(Debug)]
+struct FieldAttributes {
+    doc: String,
+    default: String,
+    value_type: String,
+    example: String,
+}
+
+impl Parse for FieldAttributes {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let doc = _parse_key_value(input, "doc")?;
+        input.parse::<Comma>()?;
+        let default = _parse_key_value(input, "default")?;
+        input.parse::<Comma>()?;
+        let value_type = _parse_key_value(input, "value_type")?;
+        input.parse::<Comma>()?;
+        let example = _parse_key_value(input, "example")?;
+        if !input.is_empty() {
+            input.parse::<Comma>()?;
+        }
+
+        Ok(FieldAttributes {
+            doc: textwrap::dedent(&doc).trim_matches('\n').to_string(),
+            default,
+            value_type,
+            example: textwrap::dedent(&example).trim_matches('\n').to_string(),
+        })
+    }
+}
+
+fn _parse_key_value(input: ParseStream, name: &str) -> syn::Result<String> {
+    let ident: proc_macro2::Ident = input.parse()?;
+    if ident != name {
+        return Err(syn::Error::new(
+            ident.span(),
+            format!("Expected `{name}` name"),
+        ));
+    }
+
+    input.parse::<Token![=]>()?;
+    let value: Lit = input.parse()?;
+
+    match &value {
+        Lit::Str(v) => Ok(v.value()),
+        _ => Err(syn::Error::new(value.span(), "Expected literal string")),
+    }
+}

src/ast/helpers.rs

@@ -301,6 +301,16 @@ pub fn match_trailing_content(stmt: &Stmt, locator: &SourceCodeLocator) -> bool
     false
 }
 
+/// Return the number of trailing empty lines following a statement.
+pub fn count_trailing_lines(stmt: &Stmt, locator: &SourceCodeLocator) -> usize {
+    let suffix =
+        locator.slice_source_code_at(&Location::new(stmt.end_location.unwrap().row() + 1, 0));
+    suffix
+        .lines()
+        .take_while(|line| line.trim().is_empty())
+        .count()
+}
+
 #[cfg(test)]
 mod tests {
     use anyhow::Result;

src/ast/operations.rs

@@ -94,23 +94,132 @@ pub fn in_nested_block<'a>(parents: &mut impl Iterator<Item = &'a Stmt>) -> bool
     })
 }
 
-/// Check if a node represents an unpacking assignment.
-pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
-    let StmtKind::Assign { targets, value, .. } = &stmt.node else {
-        return false;
-    };
-    if !targets.iter().any(|child| {
-        matches!(
-            child.node,
-            ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
-        )
-    }) {
-        return false;
+/// Returns `true` if `parent` contains `child`.
+fn contains(parent: &Expr, child: &Expr) -> bool {
+    match &parent.node {
+        ExprKind::BoolOp { values, .. } => values.iter().any(|parent| contains(parent, child)),
+        ExprKind::NamedExpr { target, value } => contains(target, child) || contains(value, child),
+        ExprKind::BinOp { left, right, .. } => contains(left, child) || contains(right, child),
+        ExprKind::UnaryOp { operand, .. } => contains(operand, child),
+        ExprKind::Lambda { body, .. } => contains(body, child),
+        ExprKind::IfExp { test, body, orelse } => {
+            contains(test, child) || contains(body, child) || contains(orelse, child)
+        }
+        ExprKind::Dict { keys, values } => keys
+            .iter()
+            .chain(values.iter())
+            .any(|parent| contains(parent, child)),
+        ExprKind::Set { elts } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::ListComp { elt, .. } => contains(elt, child),
+        ExprKind::SetComp { elt, .. } => contains(elt, child),
+        ExprKind::DictComp { key, value, .. } => contains(key, child) || contains(value, child),
+        ExprKind::GeneratorExp { elt, .. } => contains(elt, child),
+        ExprKind::Await { value } => contains(value, child),
+        ExprKind::Yield { value } => value.as_ref().map_or(false, |value| contains(value, child)),
+        ExprKind::YieldFrom { value } => contains(value, child),
+        ExprKind::Compare {
+            left, comparators, ..
+        } => contains(left, child) || comparators.iter().any(|parent| contains(parent, child)),
+        ExprKind::Call {
+            func,
+            args,
+            keywords,
+        } => {
+            contains(func, child)
+                || args.iter().any(|parent| contains(parent, child))
+                || keywords
+                    .iter()
+                    .any(|keyword| contains(&keyword.node.value, child))
+        }
+        ExprKind::FormattedValue {
+            value, format_spec, ..
+        } => {
+            contains(value, child)
+                || format_spec
+                    .as_ref()
+                    .map_or(false, |value| contains(value, child))
+        }
+        ExprKind::JoinedStr { values } => values.iter().any(|parent| contains(parent, child)),
+        ExprKind::Constant { .. } => false,
+        ExprKind::Attribute { value, .. } => contains(value, child),
+        ExprKind::Subscript { value, slice, .. } => {
+            contains(value, child) || contains(slice, child)
+        }
+        ExprKind::Starred { value, .. } => contains(value, child),
+        ExprKind::Name { .. } => parent == child,
+        ExprKind::List { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::Tuple { elts, .. } => elts.iter().any(|parent| contains(parent, child)),
+        ExprKind::Slice { lower, upper, step } => {
+            lower.as_ref().map_or(false, |value| contains(value, child))
+                || upper.as_ref().map_or(false, |value| contains(value, child))
+                || step.as_ref().map_or(false, |value| contains(value, child))
+        }
+    }
+}
+
+/// Check if a node represents an unpacking assignment.
+pub fn is_unpacking_assignment(parent: &Stmt, child: &Expr) -> bool {
+    match &parent.node {
+        StmtKind::With { items, .. } => items.iter().any(|item| {
+            if let Some(optional_vars) = &item.optional_vars {
+                if matches!(optional_vars.node, ExprKind::Tuple { .. }) {
+                    if contains(optional_vars, child) {
+                        return true;
+                    }
+                }
+            }
+            false
+        }),
+        StmtKind::Assign { targets, value, .. } => {
+            // In `(a, b) = (1, 2)`, `(1, 2)` is the target, and it is a tuple.
+            let value_is_tuple = matches!(
+                &value.node,
+                ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+            );
+            // In `(a, b) = coords = (1, 2)`, `(a, b)` and `coords` are the targets, and
+            // `(a, b`) is a tuple. (We use "tuple" as a placeholder for any
+            // unpackable expression.)
+            let targets_are_tuples = targets.iter().all(|item| {
+                matches!(
+                    item.node,
+                    ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+                )
+            });
+            // If we're looking at `a` in `(a, b) = coords = (1, 2)`, then we should
+            // identify that the current expression is in a tuple.
+            let child_in_tuple = targets_are_tuples
+                || targets.iter().any(|item| {
+                    matches!(
+                        item.node,
+                        ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+                    ) && contains(item, child)
+                });
+
+            // If our child is a tuple, and value is not, it's always an unpacking
+            // expression. Ex) `x, y = tup`
+            if child_in_tuple && !value_is_tuple {
+                return true;
+            }
+
+            // If our child isn't a tuple, but value is, it's never an unpacking expression.
+            // Ex) `coords = (1, 2)`
+            if !child_in_tuple && value_is_tuple {
+                return false;
+            }
+
+            // If our target and the value are both tuples, then it's an unpacking
+            // expression assuming there's at least one non-tuple child.
+            // Ex) Given `(x, y) = coords = 1, 2`, `(x, y)` is considered an unpacking
+            // expression. Ex) Given `(x, y) = (a, b) = 1, 2`, `(x, y)` isn't
+            // considered an unpacking expression.
+            if child_in_tuple && value_is_tuple {
+                return !targets_are_tuples;
+            }
+
+            false
+        }
+        _ => false,
     }
-    !matches!(
-        &value.node,
-        ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
-    )
 }
 
 pub type LocatedCmpop<U = ()> = Located<Cmpop, U>;
@@ -118,9 +227,9 @@ pub type LocatedCmpop<U = ()> = Located<Cmpop, U>;
 /// Extract all `Cmpop` operators from a source code snippet, with appropriate
 /// ranges.
 ///
-/// RustPython doesn't include line and column information on `Cmpop` nodes.
-/// (CPython doesn't either.) This method iterates over the token stream and
-/// re-identifies `Cmpop` nodes, annotating them with valid arnges.
+/// `RustPython` doesn't include line and column information on `Cmpop` nodes.
+/// `CPython` doesn't either. This method iterates over the token stream and
+/// re-identifies `Cmpop` nodes, annotating them with valid ranges.
 pub fn locate_cmpops(contents: &str) -> Vec<LocatedCmpop> {
     let mut tok_iter = lexer::make_tokenizer(contents)
         .flatten()

src/autofix/fixer.rs

@@ -92,7 +92,7 @@ fn apply_fixes<'a>(
     }
 
     // Add the remaining content.
-    let slice = locator.slice_source_code_at(last_pos);
+    let slice = locator.slice_source_code_at(&last_pos);
     output.append(&slice);
 
     (Cow::from(output.finish()), num_fixed)

src/cache.rs

@@ -139,20 +139,21 @@ pub fn get(
         return None;
     };
 
-    if let Ok(encoded) = read_sync(cache_key(path, settings, autofix)) {
-        match bincode::deserialize::<CheckResult>(&encoded[..]) {
-            Ok(CheckResult {
-                metadata: CacheMetadata { mtime },
-                messages,
-            }) => {
-                if FileTime::from_last_modification_time(metadata).unix_seconds() == mtime {
-                    return Some(messages);
-                }
-            }
-            Err(e) => error!("Failed to deserialize encoded cache entry: {e:?}"),
+    let encoded = read_sync(cache_key(path, settings, autofix)).ok()?;
+    let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
+        Ok(CheckResult {
+            metadata: CacheMetadata { mtime },
+            messages,
+        }) => (mtime, messages),
+        Err(e) => {
+            error!("Failed to deserialize encoded cache entry: {e:?}");
+            return None;
         }
+    };
+    if FileTime::from_last_modification_time(metadata).unix_seconds() != mtime {
+        return None;
     }
-    None
+    Some(messages)
 }
 
 /// Set a value in the cache.

src/check_ast.rs

@@ -5,7 +5,6 @@ use std::path::Path;
 
 use log::error;
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustpython_ast::Withitem;
 use rustpython_parser::ast::{
     Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
     KeywordData, Operator, Stmt, StmtKind, Suite,
@@ -20,7 +19,7 @@ use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
     Binding, BindingContext, BindingKind, ClassScope, FunctionScope, Node, Range, Scope, ScopeKind,
 };
-use crate::ast::visitor::{walk_excepthandler, walk_withitem, Visitor};
+use crate::ast::visitor::{walk_excepthandler, Visitor};
 use crate::ast::{helpers, operations, visitor};
 use crate::checks::{Check, CheckCode, CheckKind, DeferralKeyword};
 use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
@@ -36,8 +35,8 @@ use crate::visibility::{module_visibility, transition_scope, Modifier, Visibilit
 use crate::{
     docstrings, flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except,
     flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_debugger,
-    flake8_print, flake8_return, flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle,
-    pyflakes, pygrep_hooks, pylint, pyupgrade,
+    flake8_import_conventions, flake8_print, flake8_return, flake8_tidy_imports, mccabe,
+    pep8_naming, pycodestyle, pydocstyle, pyflakes, pygrep_hooks, pylint, pyupgrade,
 };
 
 const GLOBAL_SCOPE_INDEX: usize = 0;
@@ -82,7 +81,6 @@ pub struct Checker<'a> {
     in_deferred_type_definition: bool,
     in_literal: bool,
     in_subscript: bool,
-    in_withitem: bool,
     seen_import_boundary: bool,
     futures_allowed: bool,
     annotations_future_enabled: bool,
@@ -130,7 +128,6 @@ impl<'a> Checker<'a> {
             in_deferred_type_definition: false,
             in_literal: false,
             in_subscript: false,
-            in_withitem: false,
             seen_import_boundary: false,
             futures_allowed: true,
             annotations_future_enabled: false,
@@ -145,15 +142,16 @@ impl<'a> Checker<'a> {
         // If we're in an f-string, override the location. RustPython doesn't produce
         // reliable locations for expressions within f-strings, so we use the
         // span of the f-string itself as a best-effort default.
-        if let Some(range) = self.in_f_string {
-            self.checks.push(Check {
+        let check = if let Some(range) = self.in_f_string {
+            Check {
                 location: range.location,
                 end_location: range.end_location,
                 ..check
-            });
+            }
         } else {
-            self.checks.push(check);
-        }
+            check
+        };
+        self.checks.push(check);
     }
 
     /// Add multiple `Check` items to the `Checker`.
@@ -730,6 +728,19 @@ where
                             }
                         }
                     }
+
+                    if self.settings.enabled.contains(&CheckCode::ICN001) {
+                        if let Some(check) =
+                            flake8_import_conventions::checks::check_conventional_import(
+                                stmt,
+                                &alias.node.name,
+                                alias.node.asname.as_deref(),
+                                &self.settings.flake8_import_conventions.aliases,
+                            )
+                        {
+                            self.add_check(check);
+                        }
+                    }
                 }
             }
             StmtKind::ImportFrom {
@@ -1066,9 +1077,6 @@ where
                 if self.settings.enabled.contains(&CheckCode::B013) {
                     flake8_bugbear::plugins::redundant_tuple_in_exception_handler(self, handlers);
                 }
-                if self.settings.enabled.contains(&CheckCode::BLE001) {
-                    flake8_blind_except::plugins::blind_except(self, handlers);
-                }
             }
             StmtKind::Assign { targets, value, .. } => {
                 if self.settings.enabled.contains(&CheckCode::E731) {
@@ -1447,16 +1455,15 @@ where
                 if self.settings.enabled.contains(&CheckCode::UP005) {
                     pyupgrade::plugins::deprecated_unittest_alias(self, func);
                 }
+                if self.settings.enabled.contains(&CheckCode::UP012) {
+                    pyupgrade::plugins::unnecessary_encode_utf8(self, expr, func, args, keywords);
+                }
 
                 // flake8-super
                 if self.settings.enabled.contains(&CheckCode::UP008) {
                     pyupgrade::plugins::super_call_with_parameters(self, expr, func, args);
                 }
 
-                if self.settings.enabled.contains(&CheckCode::UP012) {
-                    pyupgrade::plugins::unnecessary_encode_utf8(self, expr, func, args, keywords);
-                }
-
                 // flake8-print
                 if self.settings.enabled.contains(&CheckCode::T201)
                     || self.settings.enabled.contains(&CheckCode::T203)
@@ -1464,6 +1471,7 @@ where
                     flake8_print::plugins::print_call(self, expr, func);
                 }
 
+                // flake8-bugbear
                 if self.settings.enabled.contains(&CheckCode::B004) {
                     flake8_bugbear::plugins::unreliable_callable_check(self, expr, func, args);
                 }
@@ -1491,6 +1499,15 @@ where
                         self, args, keywords,
                     );
                 }
+                if self.settings.enabled.contains(&CheckCode::B905)
+                    && self.settings.target_version >= PythonVersion::Py310
+                {
+                    flake8_bugbear::plugins::zip_without_explicit_strict(
+                        self, expr, func, keywords,
+                    );
+                }
+
+                // flake8-bandit
                 if self.settings.enabled.contains(&CheckCode::S102) {
                     if let Some(check) = flake8_bandit::plugins::exec_used(expr, func) {
                         self.add_check(check);
@@ -2327,16 +2344,25 @@ where
             ExcepthandlerKind::ExceptHandler {
                 type_, name, body, ..
             } => {
-                if self.settings.enabled.contains(&CheckCode::E722) && type_.is_none() {
-                    self.add_check(Check::new(
-                        CheckKind::DoNotUseBareExcept,
+                if self.settings.enabled.contains(&CheckCode::E722) {
+                    if let Some(check) = pycodestyle::checks::do_not_use_bare_except(
+                        type_.as_deref(),
+                        body,
                         Range::from_located(excepthandler),
-                    ));
+                    ) {
+                        self.add_check(check);
+                    }
                 }
                 if self.settings.enabled.contains(&CheckCode::B904) {
-                    {
-                        flake8_bugbear::plugins::raise_without_from_inside_except(self, body);
-                    }
+                    flake8_bugbear::plugins::raise_without_from_inside_except(self, body);
+                }
+                if self.settings.enabled.contains(&CheckCode::BLE001) {
+                    flake8_blind_except::plugins::blind_except(
+                        self,
+                        type_.as_deref(),
+                        name.as_ref().map(String::as_str),
+                        body,
+                    );
                 }
                 match name {
                     Some(name) => {
@@ -2485,13 +2511,6 @@ where
 
         self.check_builtin_arg_shadowing(&arg.node.arg, Range::from_located(arg));
     }
-
-    fn visit_withitem(&mut self, withitem: &'b Withitem) {
-        let prev_in_withitem = self.in_withitem;
-        self.in_withitem = true;
-        walk_withitem(self, withitem);
-        self.in_withitem = prev_in_withitem;
-    }
 }
 
 fn try_mark_used(scope: &mut Scope, scope_id: usize, id: &str, expr: &Expr) -> bool {
@@ -2798,7 +2817,7 @@ impl<'a> Checker<'a> {
             return;
         }
 
-        if self.in_withitem || operations::is_unpacking_assignment(parent) {
+        if operations::is_unpacking_assignment(parent, expr) {
             self.add_binding(
                 id,
                 Binding {
@@ -3142,6 +3161,8 @@ impl<'a> Checker<'a> {
     }
 
     fn check_definitions(&mut self) {
+        let mut overloaded_name: Option<String> = None;
+        self.definitions.reverse();
         while let Some((definition, visibility)) = self.definitions.pop() {
             // flake8-annotations
             if self.settings.enabled.contains(&CheckCode::ANN001)
@@ -3156,7 +3177,21 @@ impl<'a> Checker<'a> {
                 || self.settings.enabled.contains(&CheckCode::ANN206)
                 || self.settings.enabled.contains(&CheckCode::ANN401)
             {
-                flake8_annotations::plugins::definition(self, &definition, &visibility);
+                // TODO(charlie): This should be even stricter, in that an overload
+                // implementation should come immediately after the overloaded
+                // interfaces, without any AST nodes in between. Right now, we
+                // only error when traversing definition boundaries (functions,
+                // classes, etc.).
+                if !overloaded_name.map_or(false, |overloaded_name| {
+                    flake8_annotations::helpers::is_overload_impl(
+                        self,
+                        &definition,
+                        &overloaded_name,
+                    )
+                }) {
+                    flake8_annotations::plugins::definition(self, &definition, &visibility);
+                }
+                overloaded_name = flake8_annotations::helpers::overloaded_name(self, &definition);
             }
 
             // pydocstyle

src/check_imports.rs

@@ -1,10 +1,10 @@
 //! Lint rules based on import analysis.
 
-use nohash_hasher::IntSet;
 use rustpython_parser::ast::Suite;
 
 use crate::ast::visitor::Visitor;
 use crate::checks::Check;
+use crate::directives::IsortDirectives;
 use crate::isort;
 use crate::isort::track::ImportTracker;
 use crate::settings::Settings;
@@ -18,7 +18,7 @@ fn check_import_blocks(
 ) -> Vec<Check> {
     let mut checks = vec![];
     for block in tracker.into_iter() {
-        if !block.is_empty() {
+        if !block.imports.is_empty() {
             if let Some(check) = isort::plugins::check_imports(&block, locator, settings, autofix) {
                 checks.push(check);
             }
@@ -30,11 +30,11 @@ fn check_import_blocks(
 pub fn check_imports(
     python_ast: &Suite,
     locator: &SourceCodeLocator,
-    exclusions: &IntSet<usize>,
+    directives: &IsortDirectives,
     settings: &Settings,
     autofix: bool,
 ) -> Vec<Check> {
-    let mut tracker = ImportTracker::new(exclusions);
+    let mut tracker = ImportTracker::new(directives);
     for stmt in python_ast {
         tracker.visit_stmt(stmt);
     }

src/check_lines.rs

@@ -20,19 +20,18 @@ static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").unwra
 
 /// Whether the given line is too long and should be reported.
 fn should_enforce_line_length(line: &str, length: usize, limit: usize) -> bool {
-    if length > limit {
-        let mut chunks = line.split_whitespace();
-        if let (Some(first), Some(_)) = (chunks.next(), chunks.next()) {
-            // Do not enforce the line length for commented lines that end with a URL
-            // or contain only a single word.
-            !(first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)))
-        } else {
-            // Single word / no printable chars - no way to make the line shorter
-            false
-        }
-    } else {
-        false
+    if length <= limit {
+        return false;
     }
+    let mut chunks = line.split_whitespace();
+    let (Some(first), Some(_)) = (chunks.next(), chunks.next()) else {
+        // Single word / no printable chars - no way to make the line shorter
+        return false;
+    };
+
+    // Do not enforce the line length for commented lines that end with a URL
+    // or contain only a single word.
+    !(first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)))
 }
 
 pub fn check_lines(

src/check_tokens.rs

@@ -4,9 +4,9 @@ use rustpython_parser::lexer::{LexResult, Tok};
 
 use crate::checks::{Check, CheckCode};
 use crate::lex::docstring_detection::StateMachine;
-use crate::rules::checks::Context;
+use crate::ruff::checks::Context;
 use crate::source_code_locator::SourceCodeLocator;
-use crate::{eradicate, flake8_quotes, pycodestyle, rules, Settings};
+use crate::{eradicate, flake8_quotes, pycodestyle, ruff, Settings};
 
 pub fn check_tokens(
     locator: &SourceCodeLocator,
@@ -37,7 +37,7 @@ pub fn check_tokens(
         // RUF001, RUF002, RUF003
         if enforce_ambiguous_unicode_character {
             if matches!(tok, Tok::String { .. } | Tok::Comment) {
-                checks.extend(rules::checks::ambiguous_unicode_character(
+                checks.extend(ruff::checks::ambiguous_unicode_character(
                     locator,
                     start,
                     end,

src/checks.rs

@@ -10,6 +10,7 @@ use strum_macros::{AsRefStr, Display, EnumIter, EnumString};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
+use crate::checks_gen::CheckCodePrefix;
 use crate::flake8_debugger::types::DebuggerUsingType;
 use crate::flake8_quotes::settings::Quote;
 use crate::flake8_tidy_imports::settings::Strictness;
@@ -134,6 +135,7 @@ pub enum CheckCode {
     B026,
     B027,
     B904,
+    B905,
     // flake8-blind-except
     BLE001,
     // flake8-comprehensions
@@ -290,6 +292,8 @@ pub enum CheckCode {
     FBT001,
     FBT002,
     FBT003,
+    // flake8-import-conventions
+    ICN001,
     // Ruff
     RUF001,
     RUF002,
@@ -317,6 +321,7 @@ pub enum CheckCategory {
     Flake8Builtins,
     Flake8Comprehensions,
     Flake8Debugger,
+    Flake8ImportConventions,
     Flake8Print,
     Flake8Quotes,
     Flake8Return,
@@ -354,6 +359,7 @@ impl CheckCategory {
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
             CheckCategory::Flake8Debugger => "flake8-debugger",
+            CheckCategory::Flake8ImportConventions => "flake8-import-conventions",
             CheckCategory::Flake8Print => "flake8-print",
             CheckCategory::Flake8Quotes => "flake8-quotes",
             CheckCategory::Flake8Return => "flake8-return",
@@ -371,6 +377,41 @@ impl CheckCategory {
         }
     }
 
+    pub fn codes(&self) -> Vec<CheckCodePrefix> {
+        match self {
+            CheckCategory::Eradicate => vec![CheckCodePrefix::ERA],
+            CheckCategory::Flake82020 => vec![CheckCodePrefix::YTT],
+            CheckCategory::Flake8Annotations => vec![CheckCodePrefix::ANN],
+            CheckCategory::Flake8Bandit => vec![CheckCodePrefix::S],
+            CheckCategory::Flake8BlindExcept => vec![CheckCodePrefix::BLE],
+            CheckCategory::Flake8BooleanTrap => vec![CheckCodePrefix::FBT],
+            CheckCategory::Flake8Bugbear => vec![CheckCodePrefix::B],
+            CheckCategory::Flake8Builtins => vec![CheckCodePrefix::A],
+            CheckCategory::Flake8Comprehensions => vec![CheckCodePrefix::C4],
+            CheckCategory::Flake8Debugger => vec![CheckCodePrefix::T10],
+            CheckCategory::Flake8Print => vec![CheckCodePrefix::T20],
+            CheckCategory::Flake8Quotes => vec![CheckCodePrefix::Q],
+            CheckCategory::Flake8Return => vec![CheckCodePrefix::RET],
+            CheckCategory::Flake8TidyImports => vec![CheckCodePrefix::I25],
+            CheckCategory::Isort => vec![CheckCodePrefix::I00],
+            CheckCategory::McCabe => vec![CheckCodePrefix::C90],
+            CheckCategory::PEP8Naming => vec![CheckCodePrefix::N],
+            CheckCategory::Pycodestyle => vec![CheckCodePrefix::E, CheckCodePrefix::W],
+            CheckCategory::Pydocstyle => vec![CheckCodePrefix::D],
+            CheckCategory::Pyflakes => vec![CheckCodePrefix::F],
+            CheckCategory::PygrepHooks => vec![CheckCodePrefix::PGH],
+            CheckCategory::Pylint => vec![
+                CheckCodePrefix::PLC,
+                CheckCodePrefix::PLE,
+                CheckCodePrefix::PLR,
+                CheckCodePrefix::PLW,
+            ],
+            CheckCategory::Pyupgrade => vec![CheckCodePrefix::UP],
+            CheckCategory::Flake8ImportConventions => vec![CheckCodePrefix::ICN],
+            CheckCategory::Ruff => vec![CheckCodePrefix::RUF],
+        }
+    }
+
     pub fn url(&self) -> Option<(&'static str, &'static Platform)> {
         match self {
             CheckCategory::Eradicate => {
@@ -412,6 +453,7 @@ impl CheckCategory {
                 "https://pypi.org/project/flake8-debugger/4.1.2/",
                 &Platform::PyPI,
             )),
+            CheckCategory::Flake8ImportConventions => None,
             CheckCategory::Flake8Print => Some((
                 "https://pypi.org/project/flake8-print/5.0.0/",
                 &Platform::PyPI,
@@ -589,7 +631,7 @@ pub enum CheckKind {
     BuiltinArgumentShadowing(String),
     BuiltinAttributeShadowing(String),
     // flake8-blind-except
-    BlindExcept,
+    BlindExcept(String),
     // flake8-bugbear
     AbstractBaseClassWithoutAbstractMethod(String),
     AssignmentToOsEnviron,
@@ -618,6 +660,7 @@ pub enum CheckKind {
     UselessComparison,
     UselessContextlibSuppress,
     UselessExpression,
+    ZipWithoutExplicitStrict,
     // flake8-comprehensions
     UnnecessaryGeneratorList,
     UnnecessaryGeneratorSet,
@@ -774,6 +817,8 @@ pub enum CheckKind {
     BooleanPositionalValueInFunctionCall,
     // pygrep-hooks
     NoEval,
+    // flake8-import-conventions
+    ImportAliasIsNotConventional(String, String),
     // Ruff
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
@@ -924,6 +969,7 @@ impl CheckCode {
             CheckCode::B026 => CheckKind::StarArgUnpackingAfterKeywordArg,
             CheckCode::B027 => CheckKind::EmptyMethodWithoutAbstractDecorator("...".to_string()),
             CheckCode::B904 => CheckKind::RaiseWithoutFromInsideExcept,
+            CheckCode::B905 => CheckKind::ZipWithoutExplicitStrict,
             // flake8-comprehensions
             CheckCode::C400 => CheckKind::UnnecessaryGeneratorList,
             CheckCode::C401 => CheckKind::UnnecessaryGeneratorSet,
@@ -999,7 +1045,7 @@ impl CheckCode {
             CheckCode::YTT302 => CheckKind::SysVersionCmpStr10,
             CheckCode::YTT303 => CheckKind::SysVersionSlice1Referenced,
             // flake8-blind-except
-            CheckCode::BLE001 => CheckKind::BlindExcept,
+            CheckCode::BLE001 => CheckKind::BlindExcept("Exception".to_string()),
             // pyupgrade
             CheckCode::UP001 => CheckKind::UselessMetaclassType,
             CheckCode::UP003 => CheckKind::TypeOfPrimitive(Primitive::Str),
@@ -1113,6 +1159,10 @@ impl CheckCode {
             CheckCode::FBT003 => CheckKind::BooleanPositionalValueInFunctionCall,
             // pygrep-hooks
             CheckCode::PGH001 => CheckKind::NoEval,
+            // flake8-import-conventions
+            CheckCode::ICN001 => {
+                CheckKind::ImportAliasIsNotConventional("...".to_string(), "...".to_string())
+            }
             // Ruff
             CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
             CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
@@ -1165,6 +1215,7 @@ impl CheckCode {
             CheckCode::B026 => CheckCategory::Flake8Bugbear,
             CheckCode::B027 => CheckCategory::Flake8Bugbear,
             CheckCode::B904 => CheckCategory::Flake8Bugbear,
+            CheckCode::B905 => CheckCategory::Flake8Bugbear,
             CheckCode::BLE001 => CheckCategory::Flake8BlindExcept,
             CheckCode::C400 => CheckCategory::Flake8Comprehensions,
             CheckCode::C401 => CheckCategory::Flake8Comprehensions,
@@ -1288,6 +1339,7 @@ impl CheckCode {
             CheckCode::FBT002 => CheckCategory::Flake8BooleanTrap,
             CheckCode::FBT003 => CheckCategory::Flake8BooleanTrap,
             CheckCode::I001 => CheckCategory::Isort,
+            CheckCode::ICN001 => CheckCategory::Flake8ImportConventions,
             CheckCode::I252 => CheckCategory::Flake8TidyImports,
             CheckCode::N801 => CheckCategory::PEP8Naming,
             CheckCode::N802 => CheckCategory::PEP8Naming,
@@ -1465,6 +1517,7 @@ impl CheckKind {
             CheckKind::MutableArgumentDefault => &CheckCode::B006,
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::RaiseWithoutFromInsideExcept => &CheckCode::B904,
+            CheckKind::ZipWithoutExplicitStrict => &CheckCode::B905,
             CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
             CheckKind::SetAttrWithConstant => &CheckCode::B010,
             CheckKind::StarArgUnpackingAfterKeywordArg => &CheckCode::B026,
@@ -1476,7 +1529,7 @@ impl CheckKind {
             CheckKind::UselessContextlibSuppress => &CheckCode::B022,
             CheckKind::UselessExpression => &CheckCode::B018,
             // flake8-blind-except
-            CheckKind::BlindExcept => &CheckCode::BLE001,
+            CheckKind::BlindExcept(_) => &CheckCode::BLE001,
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => &CheckCode::C400,
             CheckKind::UnnecessaryGeneratorSet => &CheckCode::C401,
@@ -1633,6 +1686,8 @@ impl CheckKind {
             CheckKind::BooleanPositionalValueInFunctionCall => &CheckCode::FBT003,
             // pygrep-hooks
             CheckKind::NoEval => &CheckCode::PGH001,
+            // flake8-import-conventions
+            CheckKind::ImportAliasIsNotConventional(..) => &CheckCode::ICN001,
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
             CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
@@ -1976,6 +2031,9 @@ impl CheckKind {
                  from None to distinguish them from errors in exception handling"
                     .to_string()
             }
+            CheckKind::ZipWithoutExplicitStrict => {
+                "`zip()` without an explicit `strict=` parameter".to_string()
+            }
             // flake8-comprehensions
             CheckKind::UnnecessaryGeneratorList => {
                 "Unnecessary generator (rewrite as a `list` comprehension)".to_string()
@@ -2402,7 +2460,7 @@ impl CheckKind {
                 format!("Possible hardcoded password: `\"{string}\"`")
             }
             // flake8-blind-except
-            CheckKind::BlindExcept => "Blind except Exception: statement".to_string(),
+            CheckKind::BlindExcept(name) => format!("Do not catch blind exception: `{name}`"),
             // mccabe
             CheckKind::FunctionIsTooComplex(name, complexity) => {
                 format!("`{name}` is too complex ({complexity})")
@@ -2419,6 +2477,10 @@ impl CheckKind {
             }
             // pygrep-hooks
             CheckKind::NoEval => "No builtin `eval()` allowed".to_string(),
+            // flake8-import-conventions
+            CheckKind::ImportAliasIsNotConventional(name, asname) => {
+                format!("`{name}` should be imported as `{asname}`")
+            }
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(confusable, representant) => {
                 format!(
@@ -2497,6 +2559,8 @@ impl CheckKind {
                 | CheckKind::DoNotAssertFalse
                 | CheckKind::DoNotAssignLambda
                 | CheckKind::DuplicateHandlerException(..)
+                | CheckKind::EndsInPeriod
+                | CheckKind::EndsInPunctuation
                 | CheckKind::GetAttrWithConstant
                 | CheckKind::ImplicitReturn
                 | CheckKind::ImplicitReturnValue

src/checks_gen.rs

@@ -2,11 +2,13 @@
 
 use colored::Colorize;
 use serde::{Deserialize, Serialize};
-use strum_macros::EnumString;
+use strum_macros::{AsRefStr, EnumString};
 
 use crate::checks::CheckCode;
 
-#[derive(EnumString, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize)]
+#[derive(
+    EnumString, AsRefStr, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize,
+)]
 pub enum CheckCodePrefix {
     A,
     A0,
@@ -68,6 +70,7 @@ pub enum CheckCodePrefix {
     B9,
     B90,
     B904,
+    B905,
     BLE,
     BLE0,
     BLE00,
@@ -256,6 +259,10 @@ pub enum CheckCodePrefix {
     I2,
     I25,
     I252,
+    ICN,
+    ICN0,
+    ICN00,
+    ICN001,
     N,
     N8,
     N80,
@@ -513,6 +520,7 @@ impl CheckCodePrefix {
                 CheckCode::B026,
                 CheckCode::B027,
                 CheckCode::B904,
+                CheckCode::B905,
             ],
             CheckCodePrefix::B0 => vec![
                 CheckCode::B002,
@@ -600,9 +608,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::B025 => vec![CheckCode::B025],
             CheckCodePrefix::B026 => vec![CheckCode::B026],
             CheckCodePrefix::B027 => vec![CheckCode::B027],
-            CheckCodePrefix::B9 => vec![CheckCode::B904],
-            CheckCodePrefix::B90 => vec![CheckCode::B904],
+            CheckCodePrefix::B9 => vec![CheckCode::B904, CheckCode::B905],
+            CheckCodePrefix::B90 => vec![CheckCode::B904, CheckCode::B905],
             CheckCodePrefix::B904 => vec![CheckCode::B904],
+            CheckCodePrefix::B905 => vec![CheckCode::B905],
             CheckCodePrefix::BLE => vec![CheckCode::BLE001],
             CheckCodePrefix::BLE0 => vec![CheckCode::BLE001],
             CheckCodePrefix::BLE00 => vec![CheckCode::BLE001],
@@ -1138,6 +1147,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::I2 => vec![CheckCode::I252],
             CheckCodePrefix::I25 => vec![CheckCode::I252],
             CheckCodePrefix::I252 => vec![CheckCode::I252],
+            CheckCodePrefix::ICN => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN0 => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN00 => vec![CheckCode::ICN001],
+            CheckCodePrefix::ICN001 => vec![CheckCode::ICN001],
             CheckCodePrefix::N => vec![
                 CheckCode::N801,
                 CheckCode::N802,
@@ -1719,6 +1732,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B9 => SuffixLength::One,
             CheckCodePrefix::B90 => SuffixLength::Two,
             CheckCodePrefix::B904 => SuffixLength::Three,
+            CheckCodePrefix::B905 => SuffixLength::Three,
             CheckCodePrefix::BLE => SuffixLength::Zero,
             CheckCodePrefix::BLE0 => SuffixLength::One,
             CheckCodePrefix::BLE00 => SuffixLength::Two,
@@ -1907,6 +1921,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::I2 => SuffixLength::One,
             CheckCodePrefix::I25 => SuffixLength::Two,
             CheckCodePrefix::I252 => SuffixLength::Three,
+            CheckCodePrefix::ICN => SuffixLength::Zero,
+            CheckCodePrefix::ICN0 => SuffixLength::One,
+            CheckCodePrefix::ICN00 => SuffixLength::Two,
+            CheckCodePrefix::ICN001 => SuffixLength::Three,
             CheckCodePrefix::N => SuffixLength::Zero,
             CheckCodePrefix::N8 => SuffixLength::One,
             CheckCodePrefix::N80 => SuffixLength::Two,
@@ -2087,6 +2105,7 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::F,
     CheckCodePrefix::FBT,
     CheckCodePrefix::I,
+    CheckCodePrefix::ICN,
     CheckCodePrefix::N,
     CheckCodePrefix::PGH,
     CheckCodePrefix::PLC,

src/directives.rs

@@ -30,9 +30,15 @@ impl Flags {
     }
 }
 
+#[derive(Default)]
+pub struct IsortDirectives {
+    pub exclusions: IntSet<usize>,
+    pub splits: Vec<usize>,
+}
+
 pub struct Directives {
     pub noqa_line_for: IntMap<usize, usize>,
-    pub isort_exclusions: IntSet<usize>,
+    pub isort: IsortDirectives,
 }
 
 pub fn extract_directives(
@@ -46,10 +52,10 @@ pub fn extract_directives(
         } else {
             IntMap::default()
         },
-        isort_exclusions: if flags.contains(Flags::ISORT) {
-            extract_isort_exclusions(lxr, locator)
+        isort: if flags.contains(Flags::ISORT) {
+            extract_isort_directives(lxr, locator)
         } else {
-            IntSet::default()
+            IsortDirectives::default()
         },
     }
 }
@@ -73,63 +79,87 @@ pub fn extract_noqa_line_for(lxr: &[LexResult]) -> IntMap<usize, usize> {
 }
 
 /// Extract a set of lines over which to disable isort.
-pub fn extract_isort_exclusions(lxr: &[LexResult], locator: &SourceCodeLocator) -> IntSet<usize> {
+pub fn extract_isort_directives(lxr: &[LexResult], locator: &SourceCodeLocator) -> IsortDirectives {
     let mut exclusions: IntSet<usize> = IntSet::default();
+    let mut splits: Vec<usize> = Vec::default();
+    let mut skip_file: bool = false;
     let mut off: Option<Location> = None;
+    let mut last: Option<Location> = None;
     for &(start, ref tok, end) in lxr.iter().flatten() {
+        last = Some(end);
+
+        // No need to keep processing, but we do need to determine the last token.
+        if skip_file {
+            continue;
+        }
+
+        if !matches!(tok, Tok::Comment) {
+            continue;
+        }
+
         // TODO(charlie): Modify RustPython to include the comment text in the token.
-        if matches!(tok, Tok::Comment) {
-            let comment_text = locator.slice_source_code_range(&Range {
-                location: start,
-                end_location: end,
-            });
-            if off.is_some() {
-                if comment_text == "# isort: on" {
-                    if let Some(start) = off {
-                        for row in start.row() + 1..=end.row() {
-                            exclusions.insert(row);
-                        }
+        let comment_text = locator.slice_source_code_range(&Range {
+            location: start,
+            end_location: end,
+        });
+
+        if comment_text == "# isort: split" {
+            splits.push(start.row());
+        } else if comment_text == "# isort: skip_file" {
+            skip_file = true;
+        } else if off.is_some() {
+            if comment_text == "# isort: on" {
+                if let Some(start) = off {
+                    for row in start.row() + 1..=end.row() {
+                        exclusions.insert(row);
                     }
-                    off = None;
-                }
-            } else {
-                if comment_text.contains("isort: skip") || comment_text.contains("isort:skip") {
-                    exclusions.insert(start.row());
-                } else if comment_text == "# isort: off" {
-                    off = Some(start);
                 }
+                off = None;
             }
-        } else if matches!(tok, Tok::EndOfFile) {
-            if let Some(start) = off {
-                for row in start.row() + 1..=end.row() {
-                    exclusions.insert(row);
-                }
+        } else {
+            if comment_text.contains("isort: skip") {
+                exclusions.insert(start.row());
+            } else if comment_text == "# isort: off" {
+                off = Some(start);
             }
-            break;
         }
     }
-    exclusions
+    if skip_file {
+        // Enforce `isort: skip_file`.
+        if let Some(end) = last {
+            for row in 1..=end.row() {
+                exclusions.insert(row);
+            }
+        }
+    } else if let Some(start) = off {
+        // Enforce unterminated `isort: off`.
+        if let Some(end) = last {
+            for row in start.row() + 1..=end.row() {
+                exclusions.insert(row);
+            }
+        }
+    }
+    IsortDirectives { exclusions, splits }
 }
 
 #[cfg(test)]
 mod tests {
-    use nohash_hasher::IntMap;
+    use nohash_hasher::{IntMap, IntSet};
     use rustpython_parser::lexer;
     use rustpython_parser::lexer::LexResult;
 
-    use crate::directives::extract_noqa_line_for;
+    use crate::directives::{extract_isort_directives, extract_noqa_line_for};
+    use crate::SourceCodeLocator;
 
     #[test]
-    fn extraction() {
-        let empty: IntMap<usize, usize> = IntMap::default();
-
+    fn noqa_extraction() {
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
 y = 2
 z = x + 1",
         )
         .collect();
-        assert_eq!(extract_noqa_line_for(&lxr), empty);
+        assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "
@@ -138,7 +168,7 @@ y = 2
 z = x + 1",
         )
         .collect();
-        assert_eq!(extract_noqa_line_for(&lxr), empty);
+        assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
@@ -147,7 +177,7 @@ z = x + 1
         ",
         )
         .collect();
-        assert_eq!(extract_noqa_line_for(&lxr), empty);
+        assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
@@ -157,7 +187,7 @@ z = x + 1
         ",
         )
         .collect();
-        assert_eq!(extract_noqa_line_for(&lxr), empty);
+        assert_eq!(extract_noqa_line_for(&lxr), IntMap::default());
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = '''abc
@@ -200,4 +230,106 @@ z = x + 1",
             IntMap::from_iter([(2, 5), (3, 5), (4, 5)])
         );
     }
+
+    #[test]
+    fn isort_exclusions() {
+        let contents = "x = 1
+y = 2
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::default()
+        );
+
+        let contents = "# isort: off
+x = 1
+y = 2
+# isort: on
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::from_iter([2, 3, 4])
+        );
+
+        let contents = "# isort: off
+x = 1
+# isort: off
+y = 2
+# isort: on
+z = x + 1
+# isort: on";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::from_iter([2, 3, 4, 5])
+        );
+
+        let contents = "# isort: off
+x = 1
+y = 2
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::from_iter([2, 3, 4])
+        );
+
+        let contents = "# isort: skip_file
+x = 1
+y = 2
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::from_iter([1, 2, 3, 4])
+        );
+
+        let contents = "# isort: off
+x = 1
+# isort: on
+y = 2
+# isort: skip_file
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).exclusions,
+            IntSet::from_iter([1, 2, 3, 4, 5, 6])
+        );
+    }
+
+    #[test]
+    fn isort_splits() {
+        let contents = "x = 1
+y = 2
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(
+            extract_isort_directives(&lxr, &locator).splits,
+            Vec::<usize>::new()
+        );
+
+        let contents = "x = 1
+y = 2
+# isort: split
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(extract_isort_directives(&lxr, &locator).splits, vec![3]);
+
+        let contents = "x = 1
+y = 2  # isort: split
+z = x + 1";
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(contents).collect();
+        let locator = SourceCodeLocator::new(contents);
+        assert_eq!(extract_isort_directives(&lxr, &locator).splits, vec![2]);
+    }
 }

src/flake8_annotations/helpers.rs

@@ -0,0 +1,62 @@
+use rustpython_ast::{Arguments, Expr, Stmt, StmtKind};
+
+use crate::check_ast::Checker;
+use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::visibility;
+
+pub(super) fn match_function_def(
+    stmt: &Stmt,
+) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
+    match &stmt.node {
+        StmtKind::FunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        }
+        | StmtKind::AsyncFunctionDef {
+            name,
+            args,
+            returns,
+            body,
+            ..
+        } => (name, args, returns, body),
+        _ => panic!("Found non-FunctionDef in match_name"),
+    }
+}
+
+/// Return the name of the function, if it's overloaded.
+pub fn overloaded_name(checker: &Checker, definition: &Definition) -> Option<String> {
+    if let DefinitionKind::Function(stmt)
+    | DefinitionKind::NestedFunction(stmt)
+    | DefinitionKind::Method(stmt) = definition.kind
+    {
+        if visibility::is_overload(checker, stmt) {
+            let (name, ..) = match_function_def(stmt);
+            Some(name.to_string())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+/// Return `true` if the definition is the implementation for an overloaded
+/// function.
+pub fn is_overload_impl(checker: &Checker, definition: &Definition, overloaded_name: &str) -> bool {
+    if let DefinitionKind::Function(stmt)
+    | DefinitionKind::NestedFunction(stmt)
+    | DefinitionKind::Method(stmt) = definition.kind
+    {
+        if visibility::is_overload(checker, stmt) {
+            false
+        } else {
+            let (name, ..) = match_function_def(stmt);
+            name == overloaded_name
+        }
+    } else {
+        false
+    }
+}

src/flake8_annotations/mod.rs

@@ -1,3 +1,4 @@
+pub mod helpers;
 pub mod plugins;
 pub mod settings;
 
@@ -134,4 +135,24 @@ mod tests {
         insta::assert_yaml_snapshot!(checks);
         Ok(())
     }
+
+    #[test]
+    fn allow_overload() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/allow_overload.py"),
+            &Settings {
+                ..Settings::for_rules(vec![
+                    CheckCode::ANN201,
+                    CheckCode::ANN202,
+                    CheckCode::ANN204,
+                    CheckCode::ANN205,
+                    CheckCode::ANN206,
+                ])
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
 }

src/flake8_annotations/plugins.rs

@@ -1,4 +1,4 @@
-use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Stmt, StmtKind};
+use rustpython_ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::ast::visitor;
@@ -6,6 +6,7 @@ use crate::ast::visitor::Visitor;
 use crate::check_ast::Checker;
 use crate::checks::{CheckCode, CheckKind};
 use crate::docstrings::definition::{Definition, DefinitionKind};
+use crate::flake8_annotations::helpers::match_function_def;
 use crate::visibility::Visibility;
 use crate::{visibility, Check};
 
@@ -61,26 +62,6 @@ where
     };
 }
 
-fn match_function_def(stmt: &Stmt) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
-    match &stmt.node {
-        StmtKind::FunctionDef {
-            name,
-            args,
-            returns,
-            body,
-            ..
-        }
-        | StmtKind::AsyncFunctionDef {
-            name,
-            args,
-            returns,
-            body,
-            ..
-        } => (name, args, returns, body),
-        _ => panic!("Found non-FunctionDef in match_name"),
-    }
-}
-
 /// Generate flake8-annotation checks for a given `Definition`.
 pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &Visibility) {
     // TODO(charlie): Consider using the AST directly here rather than `Definition`.

src/flake8_annotations/settings.rs

@@ -1,22 +1,51 @@
 //! Settings for the `flake-annotations` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
-    /// Allow omission of a return type hint for `__init__` if at least one
-    /// argument is annotated.
+    #[option(
+        doc = r#"
+            Whether to allow the omission of a return type hint for `__init__` if at least one
+            argument is annotated.
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "mypy-init-return = true"
+    )]
     pub mypy_init_return: Option<bool>,
-    /// Suppress ANN000-level errors for dummy arguments, like `_`.
+    #[option(
+        doc = r#"
+            Whether to suppress `ANN000`-level errors for arguments matching the "dummy" variable
+            regex (like `_`).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "suppress-dummy-args = true"
+    )]
     pub suppress_dummy_args: Option<bool>,
-    /// Suppress ANN200-level errors for functions that meet one of the
-    /// following criteria:
-    /// - Contain no `return` statement
-    /// - Explicit `return` statement(s) all return `None` (explicitly or
-    ///   implicitly).
+    #[option(
+        doc = r#"
+            Whether to suppress `ANN200`-level errors for functions that meet either of the
+            following criteria:
+
+            - Contain no `return` statement.
+            - Explicit `return` statement(s) all return `None` (explicitly or implicitly).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "suppress-none-returning = true"
+    )]
     pub suppress_none_returning: Option<bool>,
-    /// Suppress ANN401 for dynamically typed *args and **kwargs.
+    #[option(
+        doc = "Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` \
+               arguments.",
+        default = "false",
+        value_type = "bool",
+        example = "allow-star-arg-any = true"
+    )]
     pub allow_star_arg_any: Option<bool>,
 }
 

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__allow_overload.snap

@@ -0,0 +1,14 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    MissingReturnTypePublicFunction: bar
+  location:
+    row: 29
+    column: 4
+  end_location:
+    row: 35
+    column: 0
+  fix: ~
+

src/flake8_blind_except/plugins.rs

@@ -1,21 +1,42 @@
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
+use rustpython_ast::{Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
-pub fn blind_except(checker: &mut Checker, handlers: &[Excepthandler]) {
-    for handler in handlers {
-        let ExcepthandlerKind::ExceptHandler { type_: Some(type_), .. } = &handler.node else {
-            continue;
-        };
-        let ExprKind::Name { id, .. } = &type_.node else {
-            continue;
-        };
-        for exception in ["BaseException", "Exception"] {
-            if id == exception {
+/// BLE001
+pub fn blind_except(
+    checker: &mut Checker,
+    type_: Option<&Expr>,
+    name: Option<&str>,
+    body: &[Stmt],
+) {
+    let Some(type_) = type_ else {
+        return;
+    };
+    let ExprKind::Name { id, .. } = &type_.node else {
+        return;
+    };
+    for exception in ["BaseException", "Exception"] {
+        if id == exception && checker.is_builtin(exception) {
+            // If the exception is re-raised, don't flag an error.
+            if !body.iter().any(|stmt| {
+                if let StmtKind::Raise { exc, .. } = &stmt.node {
+                    if let Some(exc) = exc {
+                        if let ExprKind::Name { id, .. } = &exc.node {
+                            name.map_or(false, |name| name == id)
+                        } else {
+                            false
+                        }
+                    } else {
+                        true
+                    }
+                } else {
+                    false
+                }
+            }) {
                 checker.add_check(Check::new(
-                    CheckKind::BlindExcept,
+                    CheckKind::BlindExcept(id.to_string()),
                     Range::from_located(type_),
                 ));
             }

src/flake8_blind_except/snapshots/ruff__flake8_blind_except__tests__BLE001_BLE.py.snap

@@ -2,31 +2,8 @@
 source: src/flake8_blind_except/mod.rs
 expression: checks
 ---
-- kind: BlindExcept
-  location:
-    row: 5
-    column: 7
-  end_location:
-    row: 5
-    column: 16
-  fix: ~
-- kind: BlindExcept
-  location:
-    row: 13
-    column: 7
-  end_location:
-    row: 13
-    column: 20
-  fix: ~
-- kind: BlindExcept
-  location:
-    row: 23
-    column: 7
-  end_location:
-    row: 23
-    column: 16
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: BaseException
   location:
     row: 25
     column: 7
@@ -34,7 +11,8 @@ expression: checks
     row: 25
     column: 20
   fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 31
     column: 7
@@ -42,15 +20,8 @@ expression: checks
     row: 31
     column: 16
   fix: ~
-- kind: BlindExcept
-  location:
-    row: 36
-    column: 11
-  end_location:
-    row: 36
-    column: 24
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 42
     column: 7
@@ -58,7 +29,8 @@ expression: checks
     row: 42
     column: 16
   fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: BaseException
   location:
     row: 45
     column: 11
@@ -66,15 +38,8 @@ expression: checks
     row: 45
     column: 24
   fix: ~
-- kind: BlindExcept
-  location:
-    row: 52
-    column: 11
-  end_location:
-    row: 52
-    column: 24
-  fix: ~
-- kind: BlindExcept
+- kind:
+    BlindExcept: Exception
   location:
     row: 54
     column: 7
@@ -82,4 +47,22 @@ expression: checks
     row: 54
     column: 16
   fix: ~
+- kind:
+    BlindExcept: Exception
+  location:
+    row: 60
+    column: 7
+  end_location:
+    row: 60
+    column: 16
+  fix: ~
+- kind:
+    BlindExcept: BaseException
+  location:
+    row: 62
+    column: 7
+  end_location:
+    row: 62
+    column: 20
+  fix: ~
 

src/flake8_bugbear/mod.rs

@@ -39,6 +39,7 @@ mod tests {
     #[test_case(CheckCode::B026, Path::new("B026.py"); "B026")]
     #[test_case(CheckCode::B027, Path::new("B027.py"); "B027")]
     #[test_case(CheckCode::B904, Path::new("B904.py"); "B904")]
+    #[test_case(CheckCode::B905, Path::new("B905.py"); "B905")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(

src/flake8_bugbear/plugins/mod.rs

@@ -23,6 +23,7 @@ pub use unused_loop_control_variable::unused_loop_control_variable;
 pub use useless_comparison::useless_comparison;
 pub use useless_contextlib_suppress::useless_contextlib_suppress;
 pub use useless_expression::useless_expression;
+pub use zip_without_explicit_strict::zip_without_explicit_strict;
 
 mod abstract_base_class;
 mod assert_false;
@@ -49,3 +50,4 @@ mod unused_loop_control_variable;
 mod useless_comparison;
 mod useless_contextlib_suppress;
 mod useless_expression;
+mod zip_without_explicit_strict;

src/flake8_bugbear/plugins/zip_without_explicit_strict.rs

@@ -0,0 +1,31 @@
+use rustpython_ast::{Expr, ExprKind, Keyword};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B905
+pub fn zip_without_explicit_strict(
+    checker: &mut Checker,
+    expr: &Expr,
+    func: &Expr,
+    kwargs: &[Keyword],
+) {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "zip"
+            && checker.is_builtin("zip")
+            && !kwargs.iter().any(|keyword| {
+                keyword
+                    .node
+                    .arg
+                    .as_ref()
+                    .map_or(false, |name| name == "strict")
+            })
+        {
+            checker.add_check(Check::new(
+                CheckKind::ZipWithoutExplicitStrict,
+                Range::from_located(expr),
+            ));
+        }
+    }
+}

src/flake8_bugbear/settings.rs

@@ -1,10 +1,23 @@
 //! Settings for the `flake8-bugbear` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = r#"
+            Additional callable functions to consider "immutable" when evaluating, e.g.,
+            `no-mutable-default-argument` checks (`B006`).
+        "#,
+        default = r#"[]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            # Allow default arguments like, e.g., `data: List[str] = fastapi.Query(None)`.
+            extend-immutable-calls = ["fastapi.Depends", "fastapi.Query"]
+        "#
+    )]
     pub extend_immutable_calls: Option<Vec<String>>,
 }
 

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__B905_B905.py.snap

@@ -0,0 +1,61 @@
+---
+source: src/flake8_bugbear/mod.rs
+expression: checks
+---
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 5
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 2
+    column: 0
+  end_location:
+    row: 2
+    column: 13
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 24
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 4
+    column: 15
+  end_location:
+    row: 4
+    column: 23
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 5
+    column: 12
+  fix: ~
+- kind: ZipWithoutExplicitStrict
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 26
+  fix: ~
+

src/flake8_import_conventions/checks.rs

@@ -0,0 +1,37 @@
+use std::collections::BTreeMap;
+
+use rustpython_ast::Stmt;
+
+use crate::ast::types::Range;
+use crate::checks::{Check, CheckKind};
+
+/// ICN001
+pub fn check_conventional_import(
+    import_from: &Stmt,
+    name: &str,
+    asname: Option<&str>,
+    conventions: &BTreeMap<String, String>,
+) -> Option<Check> {
+    let mut is_valid_import = true;
+    if let Some(expected_alias) = conventions.get(name) {
+        if !expected_alias.is_empty() {
+            if let Some(alias) = asname {
+                if expected_alias != alias {
+                    is_valid_import = false;
+                }
+            } else {
+                is_valid_import = false;
+            }
+        }
+        if !is_valid_import {
+            return Some(Check::new(
+                CheckKind::ImportAliasIsNotConventional(
+                    name.to_string(),
+                    expected_alias.to_string(),
+                ),
+                Range::from_located(import_from),
+            ));
+        }
+    }
+    None
+}

src/flake8_import_conventions/mod.rs

@@ -0,0 +1,100 @@
+pub mod checks;
+pub mod settings;
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+    use std::path::Path;
+
+    use anyhow::Result;
+
+    use crate::checks::CheckCode;
+    use crate::linter::test_path;
+    use crate::{flake8_import_conventions, Settings};
+
+    #[test]
+    fn defaults() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_import_conventions/defaults.py"),
+            &Settings::for_rule(CheckCode::ICN001),
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!("defaults", checks);
+        Ok(())
+    }
+
+    #[test]
+    fn custom() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_import_conventions/custom.py"),
+            &Settings {
+                flake8_import_conventions:
+                    flake8_import_conventions::settings::Settings::from_options(
+                        flake8_import_conventions::settings::Options {
+                            aliases: None,
+                            extend_aliases: Some(BTreeMap::from([
+                                ("dask.array".to_string(), "da".to_string()),
+                                ("dask.dataframe".to_string(), "dd".to_string()),
+                            ])),
+                        },
+                    ),
+                ..Settings::for_rule(CheckCode::ICN001)
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!("custom", checks);
+        Ok(())
+    }
+
+    #[test]
+    fn remove_defaults() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_import_conventions/remove_default.py"),
+            &Settings {
+                flake8_import_conventions:
+                    flake8_import_conventions::settings::Settings::from_options(
+                        flake8_import_conventions::settings::Options {
+                            aliases: Some(BTreeMap::from([
+                                ("altair".to_string(), "alt".to_string()),
+                                ("matplotlib.pyplot".to_string(), "plt".to_string()),
+                                ("pandas".to_string(), "pd".to_string()),
+                                ("seaborn".to_string(), "sns".to_string()),
+                            ])),
+                            extend_aliases: None,
+                        },
+                    ),
+                ..Settings::for_rule(CheckCode::ICN001)
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!("remove_default", checks);
+        Ok(())
+    }
+
+    #[test]
+    fn override_defaults() -> Result<()> {
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_import_conventions/override_default.py"),
+            &Settings {
+                flake8_import_conventions:
+                    flake8_import_conventions::settings::Settings::from_options(
+                        flake8_import_conventions::settings::Options {
+                            aliases: None,
+                            extend_aliases: Some(BTreeMap::from([(
+                                "numpy".to_string(),
+                                "nmp".to_string(),
+                            )])),
+                        },
+                    ),
+                ..Settings::for_rule(CheckCode::ICN001)
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!("override_default", checks);
+        Ok(())
+    }
+}

src/flake8_import_conventions/settings.rs

@@ -0,0 +1,84 @@
+//! Settings for import conventions.
+
+use std::collections::BTreeMap;
+
+use ruff_macros::ConfigurationOptions;
+use serde::{Deserialize, Serialize};
+
+const CONVENTIONAL_ALIASES: &[(&str, &str)] = &[
+    ("altair", "alt"),
+    ("matplotlib.pyplot", "plt"),
+    ("numpy", "np"),
+    ("pandas", "pd"),
+    ("seaborn", "sns"),
+];
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub struct Options {
+    #[option(
+        doc = "The conventional aliases for imports. These aliases can be extended by the \
+               `extend_aliases` option.",
+        default = r#"{"altair": "alt", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns"}"#,
+        value_type = "BTreeMap<String, String>",
+        example = r#"
+            # Declare the default aliases.
+            altair = "alt"
+            matplotlib.pyplot = "plt"
+            numpy = "np"
+            pandas = "pd"
+            seaborn = "sns"
+        "#
+    )]
+    pub aliases: Option<BTreeMap<String, String>>,
+    #[option(
+        doc = "A mapping of modules to their conventional import aliases. These aliases will be \
+               added to the `aliases` mapping.",
+        default = r#"{}"#,
+        value_type = "BTreeMap<String, String>",
+        example = r#"
+            # Declare a custom alias for the `matplotlib` module.
+            "dask.dataframe" = "dd"
+        "#
+    )]
+    pub extend_aliases: Option<BTreeMap<String, String>>,
+}
+
+#[derive(Debug, Hash)]
+pub struct Settings {
+    pub aliases: BTreeMap<String, String>,
+}
+
+fn default_aliases() -> BTreeMap<String, String> {
+    CONVENTIONAL_ALIASES
+        .iter()
+        .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
+        .collect::<BTreeMap<_, _>>()
+}
+
+fn resolve_aliases(options: Options) -> BTreeMap<String, String> {
+    let mut aliases = match options.aliases {
+        Some(options_aliases) => options_aliases,
+        None => default_aliases(),
+    };
+    if let Some(extend_aliases) = options.extend_aliases {
+        aliases.extend(extend_aliases);
+    }
+    aliases
+}
+
+impl Settings {
+    pub fn from_options(options: Options) -> Self {
+        Self {
+            aliases: resolve_aliases(options),
+        }
+    }
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            aliases: default_aliases(),
+        }
+    }
+}

src/flake8_import_conventions/snapshots/ruff__flake8_import_conventions__tests__custom.snap

@@ -0,0 +1,159 @@
+---
+source: src/flake8_import_conventions/mod.rs
+expression: checks
+---
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - dask.array
+      - da
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 17
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - dask.dataframe
+      - dd
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 24
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - np
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 12
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 8
+    column: 0
+  end_location:
+    row: 8
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 9
+    column: 14
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 11
+    column: 0
+  end_location:
+    row: 11
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 12
+    column: 0
+  end_location:
+    row: 12
+    column: 32
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - dask.array
+      - da
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 13
+    column: 27
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - dask.dataframe
+      - dd
+  location:
+    row: 14
+    column: 0
+  end_location:
+    row: 14
+    column: 28
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - np
+  location:
+    row: 15
+    column: 0
+  end_location:
+    row: 15
+    column: 19
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 16
+    column: 0
+  end_location:
+    row: 16
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 17
+    column: 0
+  end_location:
+    row: 17
+    column: 22
+  fix: ~
+

src/flake8_import_conventions/snapshots/ruff__flake8_import_conventions__tests__defaults.snap

@@ -0,0 +1,115 @@
+---
+source: src/flake8_import_conventions/mod.rs
+expression: checks
+---
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 24
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - np
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 12
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 14
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 9
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 10
+    column: 32
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - np
+  location:
+    row: 11
+    column: 0
+  end_location:
+    row: 11
+    column: 19
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 12
+    column: 0
+  end_location:
+    row: 12
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 13
+    column: 22
+  fix: ~
+

src/flake8_import_conventions/snapshots/ruff__flake8_import_conventions__tests__override_default.snap

@@ -0,0 +1,115 @@
+---
+source: src/flake8_import_conventions/mod.rs
+expression: checks
+---
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 24
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - nmp
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 12
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 14
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 9
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 10
+    column: 32
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - numpy
+      - nmp
+  location:
+    row: 11
+    column: 0
+  end_location:
+    row: 11
+    column: 18
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 12
+    column: 0
+  end_location:
+    row: 12
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 13
+    column: 22
+  fix: ~
+

src/flake8_import_conventions/snapshots/ruff__flake8_import_conventions__tests__remove_default.snap

@@ -0,0 +1,93 @@
+---
+source: src/flake8_import_conventions/mod.rs
+expression: checks
+---
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 24
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 13
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 14
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - altair
+      - alt
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 9
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - matplotlib.pyplot
+      - plt
+  location:
+    row: 10
+    column: 0
+  end_location:
+    row: 10
+    column: 32
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - pandas
+      - pd
+  location:
+    row: 12
+    column: 0
+  end_location:
+    row: 12
+    column: 21
+  fix: ~
+- kind:
+    ImportAliasIsNotConventional:
+      - seaborn
+      - sns
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 13
+    column: 22
+  fix: ~
+

src/flake8_quotes/settings.rs

@@ -1,5 +1,6 @@
 //! Settings for the `flake8-quotes` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
@@ -9,12 +10,55 @@ pub enum Quote {
     Double,
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = r#"
+            Quote style to prefer for inline strings (either "single" (`'`) or "double" (`"`)).
+        "#,
+        default = r#""double""#,
+        value_type = "Quote",
+        example = r#"
+            inline-quotes = "single"
+        "#
+    )]
     pub inline_quotes: Option<Quote>,
+    #[option(
+        doc = r#"
+            Quote style to prefer for multiline strings (either "single" (`'`) or "double" (`"`)).
+        "#,
+        default = r#""double""#,
+        value_type = "Quote",
+        example = r#"
+            multiline-quotes = "single"
+        "#
+    )]
     pub multiline_quotes: Option<Quote>,
+    #[option(
+        doc = r#"
+            Quote style to prefer for docstrings (either "single" (`'`) or "double" (`"`)).
+        "#,
+        default = r#""double""#,
+        value_type = "Quote",
+        example = r#"
+            docstring-quotes = "single"
+        "#
+    )]
     pub docstring_quotes: Option<Quote>,
+    #[option(
+        doc = r#"
+            Whether to avoid using single quotes if a string contains single quotes, or vice-versa
+            with double quotes, as per [PEP8](https://peps.python.org/pep-0008/#string-quotes).
+            This minimizes the need to escape quotation marks within strings.
+        "#,
+        default = r#"true"#,
+        value_type = "bool",
+        example = r#"
+            # Don't bother trying to avoid escapes.
+            avoid-escape = false
+        "#
+    )]
     pub avoid_escape: Option<bool>,
 }
 

src/flake8_tidy_imports/settings.rs

@@ -1,5 +1,6 @@
 //! Settings for the `flake8-tidy-imports` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
@@ -9,9 +10,21 @@ pub enum Strictness {
     All,
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = r#"
+            Whether to ban all relative imports (`"all"`), or only those imports that extend into
+            the parent module and beyond (`"parents"`).
+        "#,
+        default = r#""parents""#,
+        value_type = "Strictness",
+        example = r#"
+            # Disallow all relative imports.
+            ban-relative-imports = "all"
+        "#
+    )]
     pub ban_relative_imports: Option<Strictness>,
 }
 

src/fs.rs

@@ -97,7 +97,7 @@ pub(crate) fn ignores_from_path<'a>(
 
 /// Convert any path to an absolute path (based on the current working
 /// directory).
-pub(crate) fn normalize_path(path: &Path) -> PathBuf {
+pub fn normalize_path(path: &Path) -> PathBuf {
     if let Ok(path) = path.absolutize() {
         return path.to_path_buf();
     }
@@ -105,7 +105,7 @@ pub(crate) fn normalize_path(path: &Path) -> PathBuf {
 }
 
 /// Convert any path to an absolute path (based on the specified project root).
-pub(crate) fn normalize_path_to(path: &Path, project_root: &Path) -> PathBuf {
+pub fn normalize_path_to(path: &Path, project_root: &Path) -> PathBuf {
     if let Ok(path) = path.absolutize_from(project_root) {
         return path.to_path_buf();
     }
@@ -113,7 +113,7 @@ pub(crate) fn normalize_path_to(path: &Path, project_root: &Path) -> PathBuf {
 }
 
 /// Convert an absolute path to be relative to the current working directory.
-pub(crate) fn relativize_path(path: &Path) -> Cow<str> {
+pub fn relativize_path(path: &Path) -> Cow<str> {
     if let Ok(path) = path.strip_prefix(&*path_dedot::CWD) {
         return path.to_string_lossy();
     }

src/isort/format.rs

@@ -42,6 +42,15 @@ pub fn format_import_from(
     force_wrap_aliases: bool,
     is_first: bool,
 ) -> String {
+    if aliases.len() == 1
+        && aliases
+            .iter()
+            .all(|(alias, _)| alias.name == "*" && alias.asname.is_none())
+    {
+        let (single_line, ..) = format_single_line(import_from, comments, aliases, is_first);
+        return single_line;
+    }
+
     // We can only inline if: (1) none of the aliases have atop comments, and (3)
     // only the last alias (if any) has inline comments.
     if aliases
@@ -58,7 +67,7 @@ pub fn format_import_from(
     {
         let (single_line, import_length) =
             format_single_line(import_from, comments, aliases, is_first);
-        if import_length <= line_length {
+        if import_length <= line_length || aliases.iter().any(|(alias, _)| alias.name == "*") {
             return single_line;
         }
     }

src/isort/mod.rs

@@ -10,6 +10,7 @@ use rustpython_ast::{Stmt, StmtKind};
 use crate::isort::categorize::{categorize, ImportType};
 use crate::isort::comments::Comment;
 use crate::isort::sorting::{member_key, module_key};
+use crate::isort::track::{Block, Trailer};
 use crate::isort::types::{
     AliasData, CommentSet, ImportBlock, ImportFromData, Importable, OrderedImportBlock,
 };
@@ -191,7 +192,18 @@ fn normalize_imports(imports: Vec<AnnotatedImport>, combine_as_imports: bool) ->
             } => {
                 // Associate the comments with the first alias (best effort).
                 if let Some(alias) = names.first() {
-                    if alias.asname.is_none() || combine_as_imports {
+                    if alias.name == "*" {
+                        let entry = block
+                            .import_from_star
+                            .entry(ImportFromData { module, level })
+                            .or_default();
+                        for comment in atop {
+                            entry.atop.push(comment.value);
+                        }
+                        for comment in inline {
+                            entry.inline.push(comment.value);
+                        }
+                    } else if alias.asname.is_none() || combine_as_imports {
                         let entry = &mut block
                             .import_from
                             .entry(ImportFromData { module, level })
@@ -225,7 +237,18 @@ fn normalize_imports(imports: Vec<AnnotatedImport>, combine_as_imports: bool) ->
 
                 // Create an entry for every alias.
                 for alias in names {
-                    if alias.asname.is_none() || combine_as_imports {
+                    if alias.name == "*" {
+                        let entry = block
+                            .import_from_star
+                            .entry(ImportFromData { module, level })
+                            .or_default();
+                        for comment in alias.atop {
+                            entry.atop.push(comment.value);
+                        }
+                        for comment in alias.inline {
+                            entry.inline.push(comment.value);
+                        }
+                    } else if alias.asname.is_none() || combine_as_imports {
                         let entry = block
                             .import_from
                             .entry(ImportFromData { module, level })
@@ -323,6 +346,22 @@ fn categorize_imports<'a>(
             .import_from_as
             .insert((import_from, alias), comments);
     }
+    // Categorize `StmtKind::ImportFrom` (with star).
+    for (import_from, comments) in block.import_from_star {
+        let classification = categorize(
+            &import_from.module_base(),
+            import_from.level,
+            src,
+            known_first_party,
+            known_third_party,
+            extra_standard_library,
+        );
+        block_by_type
+            .entry(classification)
+            .or_default()
+            .import_from_star
+            .insert(import_from, comments);
+    }
     block_by_type
 }
 
@@ -367,6 +406,33 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
                         )
                     }),
             )
+            .chain(
+                // Include all star imports.
+                block
+                    .import_from_star
+                    .into_iter()
+                    .map(|(import_from, comments)| {
+                        (
+                            import_from,
+                            (
+                                CommentSet {
+                                    atop: comments.atop,
+                                    inline: vec![],
+                                },
+                                FxHashMap::from_iter([(
+                                    AliasData {
+                                        name: "*",
+                                        asname: None,
+                                    },
+                                    CommentSet {
+                                        atop: vec![],
+                                        inline: comments.inline,
+                                    },
+                                )]),
+                            ),
+                        )
+                    }),
+            )
             .map(|(import_from, (comments, aliases))| {
                 // Within each `StmtKind::ImportFrom`, sort the members.
                 (
@@ -399,7 +465,7 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
 
 #[allow(clippy::too_many_arguments)]
 pub fn format_imports(
-    block: &[&Stmt],
+    block: &Block,
     comments: Vec<Comment>,
     line_length: usize,
     src: &[PathBuf],
@@ -409,7 +475,8 @@ pub fn format_imports(
     combine_as_imports: bool,
     force_wrap_aliases: bool,
 ) -> String {
-    let block = annotate_imports(block, comments);
+    let trailer = &block.trailer;
+    let block = annotate_imports(&block.imports, comments);
 
     // Normalize imports (i.e., deduplicate, aggregate `from` imports).
     let block = normalize_imports(block, combine_as_imports);
@@ -458,6 +525,16 @@ pub fn format_imports(
             is_first_statement = false;
         }
     }
+    match trailer {
+        None => {}
+        Some(Trailer::Sibling) => {
+            output.append("\n");
+        }
+        Some(Trailer::FunctionDef | Trailer::ClassDef) => {
+            output.append("\n");
+            output.append("\n");
+        }
+    }
     output.finish().to_string()
 }
 
@@ -481,11 +558,14 @@ mod tests {
     #[test_case(Path::new("fit_line_length_comment.py"))]
     #[test_case(Path::new("force_wrap_aliases.py"))]
     #[test_case(Path::new("import_from_after_import.py"))]
+    #[test_case(Path::new("insert_empty_lines.py"))]
     #[test_case(Path::new("leading_prefix.py"))]
     #[test_case(Path::new("no_reorder_within_section.py"))]
+    #[test_case(Path::new("no_wrap_star.py"))]
     #[test_case(Path::new("order_by_type.py"))]
     #[test_case(Path::new("order_relative_imports_by_level.py"))]
     #[test_case(Path::new("preserve_comment_order.py"))]
+    #[test_case(Path::new("preserve_import_star.py"))]
     #[test_case(Path::new("preserve_indentation.py"))]
     #[test_case(Path::new("reorder_within_section.py"))]
     #[test_case(Path::new("separate_first_party_imports.py"))]
@@ -493,7 +573,9 @@ mod tests {
     #[test_case(Path::new("separate_local_folder_imports.py"))]
     #[test_case(Path::new("separate_third_party_imports.py"))]
     #[test_case(Path::new("skip.py"))]
+    #[test_case(Path::new("skip_file.py"))]
     #[test_case(Path::new("sort_similar_imports.py"))]
+    #[test_case(Path::new("split.py"))]
     #[test_case(Path::new("trailing_suffix.py"))]
     #[test_case(Path::new("type_comments.py"))]
     fn default(path: &Path) -> Result<()> {

src/isort/plugins.rs

@@ -1,11 +1,12 @@
 use rustpython_ast::{Location, Stmt};
 use textwrap::{dedent, indent};
 
-use crate::ast::helpers::{match_leading_content, match_trailing_content};
+use crate::ast::helpers::{count_trailing_lines, match_leading_content, match_trailing_content};
 use crate::ast::types::Range;
 use crate::ast::whitespace::leading_space;
 use crate::autofix::Fix;
 use crate::checks::CheckKind;
+use crate::isort::track::Block;
 use crate::isort::{comments, format_imports};
 use crate::{Check, Settings, SourceCodeLocator};
 
@@ -30,13 +31,13 @@ fn extract_indentation(body: &[&Stmt], locator: &SourceCodeLocator) -> String {
 
 /// I001
 pub fn check_imports(
-    body: &[&Stmt],
+    block: &Block,
     locator: &SourceCodeLocator,
     settings: &Settings,
     autofix: bool,
 ) -> Option<Check> {
-    let range = extract_range(body);
-    let indentation = extract_indentation(body, locator);
+    let range = extract_range(&block.imports);
+    let indentation = extract_indentation(&block.imports, locator);
 
     // Extract comments. Take care to grab any inline comments from the last line.
     let comments = comments::collect_comments(
@@ -48,12 +49,17 @@ pub fn check_imports(
     );
 
     // Special-cases: there's leading or trailing content in the import block.
-    let has_leading_content = match_leading_content(body.first().unwrap(), locator);
-    let has_trailing_content = match_trailing_content(body.last().unwrap(), locator);
+    let has_leading_content = match_leading_content(block.imports.first().unwrap(), locator);
+    let has_trailing_content = match_trailing_content(block.imports.last().unwrap(), locator);
+    let num_trailing_lines = if block.trailer.is_none() {
+        0
+    } else {
+        count_trailing_lines(block.imports.last().unwrap(), locator)
+    };
 
     // Generate the sorted import block.
     let expected = format_imports(
-        body,
+        block,
         comments,
         settings.line_length - indentation.len(),
         &settings.src,
@@ -81,7 +87,7 @@ pub fn check_imports(
                     Location::new(range.location.row(), 0)
                 },
                 // TODO(charlie): Preserve trailing suffixes. Right now, we strip them.
-                Location::new(range.end_location.row() + 1, 0),
+                Location::new(range.end_location.row() + 1 + num_trailing_lines, 0),
             ));
         }
         Some(check)
@@ -89,7 +95,7 @@ pub fn check_imports(
         // Expand the span the entire range, including leading and trailing space.
         let range = Range {
             location: Location::new(range.location.row(), 0),
-            end_location: Location::new(range.end_location.row() + 1, 0),
+            end_location: Location::new(range.end_location.row() + 1 + num_trailing_lines, 0),
         };
         let actual = dedent(&locator.slice_source_code_range(&range));
         if actual == expected {

src/isort/settings.rs

@@ -2,15 +2,79 @@
 
 use std::collections::BTreeSet;
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = r#"
+            Combines as imports on the same line. See isort's [`combine-as-imports`](https://pycqa.github.io/isort/docs/configuration/options.html#combine-as-imports)
+            option.
+        "#,
+        default = r#"false"#,
+        value_type = "bool",
+        example = r#"
+            combine-as-imports = true
+        "#
+    )]
     pub combine_as_imports: Option<bool>,
+    #[option(
+        doc = r#"
+            Force `import from` statements with multiple members and at least one alias (e.g.,
+            `import A as B`) to wrap such that every line contains exactly one member. For example,
+            this formatting would be retained, rather than condensing to a single line:
+
+            ```py
+            from .utils import (
+                test_directory as test_directory,
+                test_id as test_id
+            )
+            ```
+        "#,
+        default = r#"false"#,
+        value_type = "bool",
+        example = r#"
+            force-wrap-aliases = true
+        "#
+    )]
     pub force_wrap_aliases: Option<bool>,
+    #[option(
+        doc = r#"
+            A list of modules to consider first-party, regardless of whether they can be identified
+            as such via introspection of the local filesystem.
+        "#,
+        default = r#"[]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            known-first-party = ["src"]
+        "#
+    )]
     pub known_first_party: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            A list of modules to consider third-party, regardless of whether they can be identified
+            as such via introspection of the local filesystem.
+        "#,
+        default = r#"[]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            known-third-party = ["src"]
+        "#
+    )]
     pub known_third_party: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            A list of modules to consider standard-library, in addition to those known to Ruff in
+            advance.
+        "#,
+        default = r#"[]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            extra-standard-library = ["path"]
+        "#
+    )]
     pub extra_standard_library: Option<Vec<String>>,
 }
 

src/isort/snapshots/ruff__isort__tests__insert_empty_lines.py.snap

@@ -0,0 +1,80 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 3
+    column: 0
+  fix:
+    content: "import a\nimport b\n\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 3
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 6
+    column: 0
+  fix:
+    content: "import os\nimport sys\n\n\n"
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 6
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 14
+    column: 0
+  end_location:
+    row: 16
+    column: 0
+  fix:
+    content: "import os\nimport sys\n\n"
+    location:
+      row: 14
+      column: 0
+    end_location:
+      row: 16
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 33
+    column: 0
+  end_location:
+    row: 35
+    column: 0
+  fix:
+    content: "    import collections\n    import typing\n\n"
+    location:
+      row: 33
+      column: 0
+    end_location:
+      row: 35
+      column: 0
+- kind: UnsortedImports
+  location:
+    row: 39
+    column: 0
+  end_location:
+    row: 41
+    column: 0
+  fix:
+    content: "    import collections\n    import typing\n\n"
+    location:
+      row: 39
+      column: 0
+    end_location:
+      row: 41
+      column: 0
+

src/isort/snapshots/ruff__isort__tests__leading_prefix.py.snap

@@ -10,12 +10,12 @@ expression: checks
     row: 2
     column: 9
   fix:
-    content: "\nimport os\nimport sys\n"
+    content: "\nimport os\nimport sys\n\n"
     location:
       row: 1
       column: 7
     end_location:
-      row: 3
+      row: 4
       column: 0
 - kind: UnsortedImports
   location:

src/isort/snapshots/ruff__isort__tests__no_wrap_star.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 2
+    column: 0
+  fix:
+    content: "from .subscription import *  # type: ignore  # some very long comment explaining why this needs a type ignore\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 2
+      column: 0
+

src/isort/snapshots/ruff__isort__tests__preserve_import_star.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 7
+    column: 0
+  fix:
+    content: "# Above\nfrom some_module import *  # Aside\n\n# Above\nfrom some_module import some_class  # Aside\nfrom some_other_module import *\nfrom some_other_module import some_class\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 7
+      column: 0
+

src/isort/snapshots/ruff__isort__tests__skip.py.snap

@@ -2,6 +2,21 @@
 source: src/isort/mod.rs
 expression: checks
 ---
+- kind: UnsortedImports
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 8
+    column: 0
+  fix:
+    content: "import sys\n\n"
+    location:
+      row: 7
+      column: 0
+    end_location:
+      row: 8
+      column: 0
 - kind: UnsortedImports
   location:
     row: 9

src/isort/snapshots/ruff__isort__tests__skip_file.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+[]
+

src/isort/snapshots/ruff__isort__tests__split.py.snap

@@ -0,0 +1,6 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+[]
+

src/isort/snapshots/ruff__isort__tests__trailing_suffix.py.snap

@@ -10,12 +10,12 @@ expression: checks
     row: 2
     column: 9
   fix:
-    content: "import os\nimport sys\n"
+    content: "import os\nimport sys\n\n"
     location:
       row: 1
       column: 0
     end_location:
-      row: 3
+      row: 4
       column: 0
 - kind: UnsortedImports
   location:
@@ -25,7 +25,7 @@ expression: checks
     row: 6
     column: 13
   fix:
-    content: "    import os\n    import sys\n"
+    content: "    import os\n    import sys\n\n"
     location:
       row: 5
       column: 0

src/isort/track.rs

@@ -1,4 +1,3 @@
-use nohash_hasher::IntSet;
 use rustpython_ast::{
     Alias, Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Excepthandler,
     ExcepthandlerKind, Expr, ExprContext, Keyword, MatchCase, Operator, Pattern, Stmt, StmtKind,
@@ -6,34 +5,51 @@ use rustpython_ast::{
 };
 
 use crate::ast::visitor::Visitor;
+use crate::directives::IsortDirectives;
+
+pub enum Trailer {
+    Sibling,
+    ClassDef,
+    FunctionDef,
+}
+
+#[derive(Default)]
+pub struct Block<'a> {
+    pub imports: Vec<&'a Stmt>,
+    pub trailer: Option<Trailer>,
+}
 
-#[derive(Debug)]
 pub struct ImportTracker<'a> {
-    exclusions: &'a IntSet<usize>,
-    blocks: Vec<Vec<&'a Stmt>>,
+    blocks: Vec<Block<'a>>,
+    directives: &'a IsortDirectives,
+    split_index: usize,
+    nested: bool,
 }
 
 impl<'a> ImportTracker<'a> {
-    pub fn new(exclusions: &'a IntSet<usize>) -> Self {
+    pub fn new(directives: &'a IsortDirectives) -> Self {
         Self {
-            exclusions,
-            blocks: vec![vec![]],
+            directives,
+            blocks: vec![Block::default()],
+            split_index: 0,
+            nested: false,
         }
     }
 
     fn track_import(&mut self, stmt: &'a Stmt) {
         let index = self.blocks.len() - 1;
-        self.blocks[index].push(stmt);
+        self.blocks[index].imports.push(stmt);
     }
 
-    fn finalize(&mut self) {
+    fn finalize(&mut self, trailer: Option<Trailer>) {
         let index = self.blocks.len() - 1;
-        if !self.blocks[index].is_empty() {
-            self.blocks.push(vec![]);
+        if !self.blocks[index].imports.is_empty() {
+            self.blocks[index].trailer = trailer;
+            self.blocks.push(Block::default());
         }
     }
 
-    pub fn into_iter(self) -> impl IntoIterator<Item = Vec<&'a Stmt>> {
+    pub fn into_iter(self) -> impl IntoIterator<Item = Block<'a>> {
         self.blocks.into_iter()
     }
 }
@@ -43,92 +59,124 @@ where
     'b: 'a,
 {
     fn visit_stmt(&mut self, stmt: &'b Stmt) {
+        // Track manual splits.
+        while self.split_index < self.directives.splits.len() {
+            if stmt.location.row() >= self.directives.splits[self.split_index] {
+                self.finalize(Some(if self.nested {
+                    Trailer::Sibling
+                } else {
+                    match &stmt.node {
+                        StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                            Trailer::FunctionDef
+                        }
+                        StmtKind::ClassDef { .. } => Trailer::ClassDef,
+                        _ => Trailer::Sibling,
+                    }
+                }));
+                self.split_index += 1;
+            } else {
+                break;
+            }
+        }
+
         // Track imports.
         if matches!(
             stmt.node,
             StmtKind::Import { .. } | StmtKind::ImportFrom { .. }
-        ) && !self.exclusions.contains(&stmt.location.row())
+        ) && !self.directives.exclusions.contains(&stmt.location.row())
         {
             self.track_import(stmt);
         } else {
-            self.finalize();
+            self.finalize(Some(if self.nested {
+                Trailer::Sibling
+            } else {
+                match &stmt.node {
+                    StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                        Trailer::FunctionDef
+                    }
+                    StmtKind::ClassDef { .. } => Trailer::ClassDef,
+                    _ => Trailer::Sibling,
+                }
+            }));
         }
 
         // Track scope.
+        let prev_nested = self.nested;
+        self.nested = true;
         match &stmt.node {
             StmtKind::FunctionDef { body, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::AsyncFunctionDef { body, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::ClassDef { body, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::For { body, orelse, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in orelse {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::AsyncFor { body, orelse, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in orelse {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::While { body, orelse, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in orelse {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::If { body, orelse, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in orelse {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::With { body, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::AsyncWith { body, .. } => {
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             StmtKind::Match { cases, .. } => {
                 for match_case in cases {
@@ -148,20 +196,21 @@ where
                 for stmt in body {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in orelse {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
 
                 for stmt in finalbody {
                     self.visit_stmt(stmt);
                 }
-                self.finalize();
+                self.finalize(None);
             }
             _ => {}
         }
+        self.nested = prev_nested;
     }
 
     fn visit_annotation(&mut self, _: &'b Expr) {}
@@ -183,11 +232,16 @@ where
     fn visit_comprehension(&mut self, _: &'b Comprehension) {}
 
     fn visit_excepthandler(&mut self, excepthandler: &'b Excepthandler) {
+        let prev_nested = self.nested;
+        self.nested = true;
+
         let ExcepthandlerKind::ExceptHandler { body, .. } = &excepthandler.node;
         for stmt in body {
             self.visit_stmt(stmt);
         }
-        self.finalize();
+        self.finalize(None);
+
+        self.nested = prev_nested;
     }
 
     fn visit_arguments(&mut self, _: &'b Arguments) {}
@@ -204,7 +258,7 @@ where
         for stmt in &match_case.body {
             self.visit_stmt(stmt);
         }
-        self.finalize();
+        self.finalize(None);
     }
 
     fn visit_pattern(&mut self, _: &'b Pattern) {}

src/isort/types.rs

@@ -59,6 +59,9 @@ pub struct ImportBlock<'a> {
     // Set of (module, level, name, asname), used to track re-exported 'from' imports.
     // Ex) `from module import member as member`
     pub import_from_as: FxHashMap<(ImportFromData<'a>, AliasData<'a>), CommentSet<'a>>,
+    // Map from (module, level) to `AliasData`, used to track star imports.
+    // Ex) `from module import *`
+    pub import_from_star: FxHashMap<ImportFromData<'a>, CommentSet<'a>>,
 }
 
 type AliasDataWithComments<'a> = (AliasData<'a>, CommentSet<'a>);

src/lib.rs

@@ -49,6 +49,7 @@ pub mod flake8_bugbear;
 mod flake8_builtins;
 mod flake8_comprehensions;
 mod flake8_debugger;
+mod flake8_import_conventions;
 mod flake8_print;
 pub mod flake8_quotes;
 mod flake8_return;
@@ -70,7 +71,7 @@ mod pygrep_hooks;
 mod pylint;
 mod python;
 mod pyupgrade;
-mod rules;
+mod ruff;
 mod rustpython_helpers;
 pub mod settings;
 pub mod source_code_locator;

src/linter.rs

@@ -89,7 +89,7 @@ pub(crate) fn check_path(
                     checks.extend(check_imports(
                         &python_ast,
                         locator,
-                        &directives.isort_exclusions,
+                        &directives.isort,
                         settings,
                         autofix,
                     ));
@@ -133,7 +133,7 @@ pub(crate) fn check_path(
     Ok(checks)
 }
 
-const MAX_ITERATIONS: usize = 100;
+const MAX_ITERATIONS: usize = 1;
 
 /// Lint the source code at the given `Path`.
 pub fn lint_path(
@@ -193,7 +193,7 @@ pub fn add_noqa_to_path(path: &Path, settings: &Settings) -> Result<usize> {
         &locator,
         &Directives {
             noqa_line_for: IntMap::default(),
-            isort_exclusions: directives.isort_exclusions,
+            isort: directives.isort,
         },
         settings,
         false,

src/main.rs

@@ -17,6 +17,7 @@ use std::process::ExitCode;
 use std::sync::mpsc::channel;
 use std::time::Instant;
 
+use ::ruff::autofix::fixer;
 use ::ruff::checks::{CheckCode, CheckKind};
 use ::ruff::cli::{collect_per_file_ignores, extract_log_level, Cli};
 use ::ruff::fs::iter_python_files;
@@ -29,7 +30,7 @@ use ::ruff::settings::types::SerializationFormat;
 use ::ruff::settings::{pyproject, Settings};
 #[cfg(feature = "update-informer")]
 use ::ruff::updates;
-use ::ruff::{cache, commands};
+use ::ruff::{cache, commands, fs};
 use anyhow::Result;
 use clap::{CommandFactory, Parser};
 use colored::Colorize;
@@ -37,7 +38,6 @@ use log::{debug, error};
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
-use ruff::autofix::fixer;
 use rustpython_ast::Location;
 use walkdir::DirEntry;
 
@@ -210,10 +210,12 @@ fn inner_main() -> Result<ExitCode> {
     }
 
     // Find the project root and pyproject.toml.
-    let project_root = pyproject::find_project_root(&cli.files);
-    let pyproject = cli
-        .config
-        .or_else(|| pyproject::find_pyproject_toml(project_root.as_ref()));
+    let config: Option<PathBuf> = cli.config;
+    let project_root = config.as_ref().map_or_else(
+        || pyproject::find_project_root(&cli.files),
+        |config| config.parent().map(fs::normalize_path),
+    );
+    let pyproject = config.or_else(|| pyproject::find_pyproject_toml(project_root.as_ref()));
 
     // Reconcile configuration from pyproject.toml and command-line arguments.
     let mut configuration =

src/mccabe/settings.rs

@@ -1,10 +1,20 @@
 //! Settings for the `mccabe` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = "The maximum McCabe complexity to allow before triggering `C901` errors.",
+        default = "10",
+        value_type = "usize",
+        example = r#"
+            # Flag errors (`C901`) whenever the complexity level exceeds 5.
+            max-complexity = 5
+        "#
+    )]
     pub max_complexity: Option<usize>,
 }
 
@@ -14,8 +24,7 @@ pub struct Settings {
 }
 
 impl Settings {
-    #[allow(clippy::needless_pass_by_value)]
-    pub fn from_options(options: Options) -> Self {
+    pub fn from_options(options: &Options) -> Self {
         Self {
             max_complexity: options.max_complexity.unwrap_or_default(),
         }

src/pep8_naming/settings.rs

@@ -1,5 +1,6 @@
 //! Settings for the `pep8-naming` plugin.
 
+use ruff_macros::ConfigurationOptions;
 use serde::{Deserialize, Serialize};
 
 const IGNORE_NAMES: [&str; 12] = [
@@ -21,11 +22,47 @@ const CLASSMETHOD_DECORATORS: [&str; 1] = ["classmethod"];
 
 const STATICMETHOD_DECORATORS: [&str; 1] = ["staticmethod"];
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default, ConfigurationOptions)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    #[option(
+        doc = r#"
+            A list of names to ignore when considering `pep8-naming` violations.
+        "#,
+        default = r#"["setUp", "tearDown", "setUpClass", "tearDownClass", "setUpModule", "tearDownModule", "asyncSetUp", "asyncTearDown", "setUpTestData", "failureException", "longMessage", "maxDiff"]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            ignore-names = ["callMethod"]
+        "#
+    )]
     pub ignore_names: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            A list of decorators that, when applied to a method, indicate that the method should be
+            treated as a class method. For example, Ruff will expect that any method decorated by a
+            decorator in this list takes a `cls` argument as its first argument.
+        "#,
+        default = r#"["classmethod"]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            # Allow Pydantic's `@validator` decorator to trigger class method treatment.
+            classmethod-decorators = ["classmethod", "pydantic.validator"]
+        "#
+    )]
     pub classmethod_decorators: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            A list of decorators that, when applied to a method, indicate that the method should be
+            treated as a static method. For example, Ruff will expect that any method decorated by a
+            decorator in this list has no `self` or `cls` argument.
+        "#,
+        default = r#"["staticmethod"]"#,
+        value_type = "Vec<String>",
+        example = r#"
+            # Allow a shorthand alias, `@stcmthd`, to trigger static method treatment.
+            staticmethod-decorators = ["staticmethod", "stcmthd"]
+        "#
+    )]
     pub staticmethod_decorators: Option<Vec<String>>,
 }
 

src/printer.rs

@@ -46,14 +46,13 @@ impl<'a> Printer<'a> {
 
     fn pre_text(&self, diagnostics: &Diagnostics) {
         if self.log_level >= &LogLevel::Default {
-            if diagnostics.fixed > 0 {
-                println!(
-                    "Found {} error(s) ({} fixed).",
-                    diagnostics.messages.len(),
-                    diagnostics.fixed,
-                );
-            } else if !diagnostics.messages.is_empty() {
-                println!("Found {} error(s).", diagnostics.messages.len());
+            let fixed = diagnostics.fixed;
+            let remaining = diagnostics.messages.len();
+            let total = fixed + remaining;
+            if fixed > 0 {
+                println!("Found {total} error(s) ({fixed} fixed, {remaining} remaining).");
+            } else if remaining > 0 {
+                println!("Found {remaining} error(s).");
             }
         }
     }

src/pycodestyle/checks.rs

@@ -1,11 +1,65 @@
 use itertools::izip;
-use rustpython_ast::Location;
+use rustpython_ast::{Location, Stmt, StmtKind};
 use rustpython_parser::ast::{Cmpop, Expr, ExprKind};
 
 use crate::ast::types::Range;
 use crate::checks::{Check, CheckKind};
 use crate::source_code_locator::SourceCodeLocator;
 
+/// E721
+pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+
+    for (op, right) in izip!(ops, comparators) {
+        if !matches!(op, Cmpop::Is | Cmpop::IsNot | Cmpop::Eq | Cmpop::NotEq) {
+            continue;
+        }
+        match &right.node {
+            ExprKind::Call { func, args, .. } => {
+                if let ExprKind::Name { id, .. } = &func.node {
+                    // Ex) type(False)
+                    if id == "type" {
+                        if let Some(arg) = args.first() {
+                            // Allow comparison for types which are not obvious.
+                            if !matches!(arg.node, ExprKind::Name { .. }) {
+                                checks.push(Check::new(CheckKind::TypeComparison, location));
+                            }
+                        }
+                    }
+                }
+            }
+            ExprKind::Attribute { value, .. } => {
+                if let ExprKind::Name { id, .. } = &value.node {
+                    // Ex) types.IntType
+                    if id == "types" {
+                        checks.push(Check::new(CheckKind::TypeComparison, location));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    checks
+}
+
+/// E722
+pub fn do_not_use_bare_except(
+    type_: Option<&Expr>,
+    body: &[Stmt],
+    location: Range,
+) -> Option<Check> {
+    if type_.is_none()
+        && !body
+            .iter()
+            .any(|stmt| matches!(stmt.node, StmtKind::Raise { exc: None, .. }))
+    {
+        Some(Check::new(CheckKind::DoNotUseBareExcept, location))
+    } else {
+        None
+    }
+}
+
 fn is_ambiguous_name(name: &str) -> bool {
     name == "l" || name == "I" || name == "O"
 }
@@ -46,43 +100,6 @@ pub fn ambiguous_function_name(name: &str, location: Range) -> Option<Check> {
     }
 }
 
-/// E721
-pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    for (op, right) in izip!(ops, comparators) {
-        if !matches!(op, Cmpop::Is | Cmpop::IsNot | Cmpop::Eq | Cmpop::NotEq) {
-            continue;
-        }
-        match &right.node {
-            ExprKind::Call { func, args, .. } => {
-                if let ExprKind::Name { id, .. } = &func.node {
-                    // Ex) type(False)
-                    if id == "type" {
-                        if let Some(arg) = args.first() {
-                            // Allow comparison for types which are not obvious.
-                            if !matches!(arg.node, ExprKind::Name { .. }) {
-                                checks.push(Check::new(CheckKind::TypeComparison, location));
-                            }
-                        }
-                    }
-                }
-            }
-            ExprKind::Attribute { value, .. } => {
-                if let ExprKind::Name { id, .. } = &value.node {
-                    // Ex) types.IntType
-                    if id == "types" {
-                        checks.push(Check::new(CheckKind::TypeComparison, location));
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    checks
-}
-
 // See: https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
 const VALID_ESCAPE_SEQUENCES: &[char; 23] = &[
     '\n', '\\', '\'', '"', 'a', 'b', 'f', 'n', 'r', 't', 'v', '0', '1', '2', '3', '4', '5', '6',

src/pydocstyle/helpers.rs

@@ -0,0 +1,43 @@
+use rustpython_ast::Expr;
+
+use crate::ast::types::Range;
+use crate::docstrings::constants;
+use crate::SourceCodeLocator;
+
+/// Return the leading quote string for a docstring (e.g., `"""`).
+pub fn leading_quote<'a>(docstring: &Expr, locator: &'a SourceCodeLocator) -> Option<&'a str> {
+    if let Some(first_line) = locator
+        .slice_source_code_range(&Range::from_located(docstring))
+        .lines()
+        .next()
+        .map(str::to_lowercase)
+    {
+        for pattern in constants::TRIPLE_QUOTE_PREFIXES
+            .iter()
+            .chain(constants::SINGLE_QUOTE_PREFIXES)
+        {
+            if first_line.starts_with(pattern) {
+                return Some(pattern);
+            }
+        }
+    }
+    None
+}
+
+/// Return the index of the first logical line in a string.
+pub fn logical_line(content: &str) -> Option<usize> {
+    // Find the first logical line.
+    let mut logical_line = None;
+    for (i, line) in content.lines().enumerate() {
+        if line.trim().is_empty() {
+            // Empty line. If this is the line _after_ the first logical line, stop.
+            if logical_line.is_some() {
+                break;
+            }
+        } else {
+            // Non-empty line. Store the index.
+            logical_line = Some(i);
+        }
+    }
+    logical_line
+}

src/pydocstyle/mod.rs

@@ -1,3 +1,4 @@
+mod helpers;
 pub mod plugins;
 
 #[cfg(test)]
@@ -36,7 +37,8 @@ mod tests {
     #[test_case(CheckCode::D214, Path::new("sections.py"); "D214")]
     #[test_case(CheckCode::D215, Path::new("sections.py"); "D215")]
     #[test_case(CheckCode::D300, Path::new("D.py"); "D300")]
-    #[test_case(CheckCode::D400, Path::new("D.py"); "D400")]
+    #[test_case(CheckCode::D400, Path::new("D.py"); "D400_0")]
+    #[test_case(CheckCode::D400, Path::new("D400.py"); "D400_1")]
     #[test_case(CheckCode::D402, Path::new("D.py"); "D402")]
     #[test_case(CheckCode::D403, Path::new("D.py"); "D403")]
     #[test_case(CheckCode::D404, Path::new("D.py"); "D404")]

src/pydocstyle/plugins.rs

@@ -16,6 +16,7 @@ use crate::docstrings::constants;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::docstrings::sections::{section_contexts, SectionContext};
 use crate::docstrings::styles::SectionStyle;
+use crate::pydocstyle::helpers::{leading_quote, logical_line};
 use crate::visibility::{is_init, is_magic, is_overload, is_override, is_staticmethod, Visibility};
 
 /// D100, D101, D102, D103, D104, D105, D106, D107
@@ -388,15 +389,17 @@ pub fn blank_after_summary(checker: &mut Checker, definition: &Definition) {
                 }
             }
 
-            // Insert one blank line after the summary (replacing any existing lines).
-            check.amend(Fix::replacement(
-                "\n".to_string(),
-                Location::new(docstring.location.row() + summary_line + 1, 0),
-                Location::new(
-                    docstring.location.row() + summary_line + 1 + blanks_count,
-                    0,
-                ),
-            ));
+            if blanks_count > 1 {
+                // Insert one blank line after the summary (replacing any existing lines).
+                check.amend(Fix::replacement(
+                    "\n".to_string(),
+                    Location::new(docstring.location.row() + summary_line + 1, 0),
+                    Location::new(
+                        docstring.location.row() + summary_line + 1 + blanks_count,
+                        0,
+                    ),
+                ));
+            }
         }
         checker.add_check(check);
     }
@@ -619,18 +622,11 @@ pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition)
         Range::from_located(docstring),
     );
     if checker.patch(check.kind.code()) {
-        if let Some(first_line) = checker
-            .locator
-            .slice_source_code_range(&Range::from_located(docstring))
-            .lines()
-            .next()
-            .map(str::to_lowercase)
-        {
-            for pattern in constants::TRIPLE_QUOTE_PREFIXES
-                .iter()
-                .chain(constants::SINGLE_QUOTE_PREFIXES)
-            {
-                if first_line.starts_with(pattern) {
+        if let Some(pattern) = leading_quote(docstring, checker.locator) {
+            if let Some(quote) = pattern.chars().last() {
+                // If removing whitespace would lead to an invalid string of quote
+                // characters, avoid applying the fix.
+                if !trimmed.ends_with(quote) {
                     check.amend(Fix::replacement(
                         trimmed.to_string(),
                         Location::new(
@@ -642,7 +638,6 @@ pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition)
                             docstring.location.column() + pattern.len() + line.chars().count(),
                         ),
                     ));
-                    break;
                 }
             }
         }
@@ -741,16 +736,30 @@ pub fn ends_with_period(checker: &mut Checker, definition: &Definition) {
     } = &docstring.node else {
         return;
     };
-    let Some(string) = string.trim().lines().next() else {
-        return;
-    };
-    if string.ends_with('.') {
-        return;
-    };
-    checker.add_check(Check::new(
-        CheckKind::EndsInPeriod,
-        Range::from_located(docstring),
-    ));
+    if let Some(index) = logical_line(string) {
+        let line = string.lines().nth(index).unwrap();
+        let trimmed = line.trim_end();
+        if !trimmed.ends_with('.') {
+            let mut check = Check::new(CheckKind::EndsInPeriod, Range::from_located(docstring));
+            // Best-effort autofix: avoid adding a period after other punctuation marks.
+            if checker.patch(&CheckCode::D400) && !trimmed.ends_with(':') && !trimmed.ends_with(';')
+            {
+                if let Some((row, column)) = if index == 0 {
+                    leading_quote(docstring, checker.locator).map(|pattern| {
+                        (
+                            docstring.location.row(),
+                            docstring.location.column() + pattern.len() + trimmed.chars().count(),
+                        )
+                    })
+                } else {
+                    Some((docstring.location.row() + index, trimmed.chars().count()))
+                } {
+                    check.amend(Fix::insertion(".".to_string(), Location::new(row, column)));
+                }
+            }
+            checker.add_check(check);
+        };
+    }
 }
 
 /// D402
@@ -868,16 +877,31 @@ pub fn ends_with_punctuation(checker: &mut Checker, definition: &Definition) {
     } = &docstring.node else {
         return
     };
-    let Some(string) = string.trim().lines().next() else {
-        return
-    };
-    if string.ends_with('.') || string.ends_with('!') || string.ends_with('?') {
-        return;
+    if let Some(index) = logical_line(string) {
+        let line = string.lines().nth(index).unwrap();
+        let trimmed = line.trim_end();
+        if !(trimmed.ends_with('.') || trimmed.ends_with('!') || trimmed.ends_with('?')) {
+            let mut check =
+                Check::new(CheckKind::EndsInPunctuation, Range::from_located(docstring));
+            // Best-effort autofix: avoid adding a period after other punctuation marks.
+            if checker.patch(&CheckCode::D415) && !trimmed.ends_with(':') && !trimmed.ends_with(';')
+            {
+                if let Some((row, column)) = if index == 0 {
+                    leading_quote(docstring, checker.locator).map(|pattern| {
+                        (
+                            docstring.location.row(),
+                            docstring.location.column() + pattern.len() + trimmed.chars().count(),
+                        )
+                    })
+                } else {
+                    Some((docstring.location.row() + index, trimmed.chars().count()))
+                } {
+                    check.amend(Fix::insertion(".".to_string(), Location::new(row, column)));
+                }
+            }
+            checker.add_check(check);
+        };
     }
-    checker.add_check(Check::new(
-        CheckKind::EndsInPunctuation,
-        Range::from_located(docstring),
-    ));
 }
 
 /// D418

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D205_D.py.snap

@@ -9,14 +9,7 @@ expression: checks
   end_location:
     row: 203
     column: 7
-  fix:
-    content: "\n"
-    location:
-      row: 201
-      column: 0
-    end_location:
-      row: 201
-      column: 0
+  fix: ~
 - kind: BlankLineAfterSummary
   location:
     row: 210

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D210_D.py.snap

@@ -47,4 +47,12 @@ expression: checks
     end_location:
       row: 299
       column: 36
+- kind: NoSurroundingWhitespace
+  location:
+    row: 581
+    column: 4
+  end_location:
+    row: 581
+    column: 51
+  fix: ~
 

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D400_D.py.snap

@@ -9,7 +9,14 @@ expression: checks
   end_location:
     row: 355
     column: 17
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 355
+      column: 14
+    end_location:
+      row: 355
+      column: 14
 - kind: EndsInPeriod
   location:
     row: 406
@@ -17,7 +24,14 @@ expression: checks
   end_location:
     row: 406
     column: 39
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 406
+      column: 36
+    end_location:
+      row: 406
+      column: 36
 - kind: EndsInPeriod
   location:
     row: 410
@@ -25,7 +39,14 @@ expression: checks
   end_location:
     row: 410
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 410
+      column: 21
+    end_location:
+      row: 410
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 416
@@ -33,7 +54,14 @@ expression: checks
   end_location:
     row: 416
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 416
+      column: 21
+    end_location:
+      row: 416
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 422
@@ -41,7 +69,14 @@ expression: checks
   end_location:
     row: 422
     column: 49
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 422
+      column: 46
+    end_location:
+      row: 422
+      column: 46
 - kind: EndsInPeriod
   location:
     row: 429
@@ -49,7 +84,14 @@ expression: checks
   end_location:
     row: 429
     column: 63
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 429
+      column: 60
+    end_location:
+      row: 429
+      column: 60
 - kind: EndsInPeriod
   location:
     row: 470
@@ -57,7 +99,14 @@ expression: checks
   end_location:
     row: 470
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 470
+      column: 21
+    end_location:
+      row: 470
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 475
@@ -65,7 +114,14 @@ expression: checks
   end_location:
     row: 475
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 475
+      column: 21
+    end_location:
+      row: 475
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 480
@@ -73,7 +129,14 @@ expression: checks
   end_location:
     row: 480
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 480
+      column: 21
+    end_location:
+      row: 480
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 487
@@ -81,7 +144,14 @@ expression: checks
   end_location:
     row: 487
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 487
+      column: 21
+    end_location:
+      row: 487
+      column: 21
 - kind: EndsInPeriod
   location:
     row: 509
@@ -89,7 +159,14 @@ expression: checks
   end_location:
     row: 509
     column: 34
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 509
+      column: 31
+    end_location:
+      row: 509
+      column: 31
 - kind: EndsInPeriod
   location:
     row: 514
@@ -97,7 +174,14 @@ expression: checks
   end_location:
     row: 514
     column: 33
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 514
+      column: 30
+    end_location:
+      row: 514
+      column: 30
 - kind: EndsInPeriod
   location:
     row: 520
@@ -105,5 +189,27 @@ expression: checks
   end_location:
     row: 520
     column: 32
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 520
+      column: 29
+    end_location:
+      row: 520
+      column: 29
+- kind: EndsInPeriod
+  location:
+    row: 581
+    column: 4
+  end_location:
+    row: 581
+    column: 51
+  fix:
+    content: "."
+    location:
+      row: 581
+      column: 47
+    end_location:
+      row: 581
+      column: 47
 

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D400_D400.py.snap

@@ -0,0 +1,185 @@
+---
+source: src/pydocstyle/mod.rs
+expression: checks
+---
+- kind: EndsInPeriod
+  location:
+    row: 2
+    column: 4
+  end_location:
+    row: 2
+    column: 36
+  fix:
+    content: "."
+    location:
+      row: 2
+      column: 35
+    end_location:
+      row: 2
+      column: 35
+- kind: EndsInPeriod
+  location:
+    row: 7
+    column: 4
+  end_location:
+    row: 7
+    column: 40
+  fix:
+    content: "."
+    location:
+      row: 7
+      column: 37
+    end_location:
+      row: 7
+      column: 37
+- kind: EndsInPeriod
+  location:
+    row: 12
+    column: 4
+  end_location:
+    row: 15
+    column: 7
+  fix:
+    content: "."
+    location:
+      row: 14
+      column: 28
+    end_location:
+      row: 14
+      column: 28
+- kind: EndsInPeriod
+  location:
+    row: 20
+    column: 4
+  end_location:
+    row: 20
+    column: 40
+  fix:
+    content: "."
+    location:
+      row: 20
+      column: 37
+    end_location:
+      row: 20
+      column: 37
+- kind: EndsInPeriod
+  location:
+    row: 25
+    column: 4
+  end_location:
+    row: 27
+    column: 31
+  fix:
+    content: "."
+    location:
+      row: 27
+      column: 28
+    end_location:
+      row: 27
+      column: 28
+- kind: EndsInPeriod
+  location:
+    row: 32
+    column: 4
+  end_location:
+    row: 34
+    column: 52
+  fix:
+    content: "."
+    location:
+      row: 34
+      column: 48
+    end_location:
+      row: 34
+      column: 48
+- kind: EndsInPeriod
+  location:
+    row: 40
+    column: 4
+  end_location:
+    row: 40
+    column: 37
+  fix:
+    content: "."
+    location:
+      row: 40
+      column: 36
+    end_location:
+      row: 40
+      column: 36
+- kind: EndsInPeriod
+  location:
+    row: 45
+    column: 4
+  end_location:
+    row: 45
+    column: 41
+  fix:
+    content: "."
+    location:
+      row: 45
+      column: 38
+    end_location:
+      row: 45
+      column: 38
+- kind: EndsInPeriod
+  location:
+    row: 50
+    column: 4
+  end_location:
+    row: 53
+    column: 7
+  fix:
+    content: "."
+    location:
+      row: 52
+      column: 28
+    end_location:
+      row: 52
+      column: 28
+- kind: EndsInPeriod
+  location:
+    row: 58
+    column: 4
+  end_location:
+    row: 58
+    column: 41
+  fix:
+    content: "."
+    location:
+      row: 58
+      column: 38
+    end_location:
+      row: 58
+      column: 38
+- kind: EndsInPeriod
+  location:
+    row: 63
+    column: 4
+  end_location:
+    row: 65
+    column: 31
+  fix:
+    content: "."
+    location:
+      row: 65
+      column: 28
+    end_location:
+      row: 65
+      column: 28
+- kind: EndsInPeriod
+  location:
+    row: 70
+    column: 4
+  end_location:
+    row: 72
+    column: 52
+  fix:
+    content: "."
+    location:
+      row: 72
+      column: 48
+    end_location:
+      row: 72
+      column: 48
+

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D415_D.py.snap

@@ -9,7 +9,14 @@ expression: checks
   end_location:
     row: 355
     column: 17
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 355
+      column: 14
+    end_location:
+      row: 355
+      column: 14
 - kind: EndsInPunctuation
   location:
     row: 406
@@ -17,7 +24,14 @@ expression: checks
   end_location:
     row: 406
     column: 39
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 406
+      column: 36
+    end_location:
+      row: 406
+      column: 36
 - kind: EndsInPunctuation
   location:
     row: 410
@@ -25,7 +39,14 @@ expression: checks
   end_location:
     row: 410
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 410
+      column: 21
+    end_location:
+      row: 410
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 416
@@ -33,7 +54,14 @@ expression: checks
   end_location:
     row: 416
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 416
+      column: 21
+    end_location:
+      row: 416
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 422
@@ -41,7 +69,14 @@ expression: checks
   end_location:
     row: 422
     column: 49
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 422
+      column: 46
+    end_location:
+      row: 422
+      column: 46
 - kind: EndsInPunctuation
   location:
     row: 429
@@ -49,7 +84,14 @@ expression: checks
   end_location:
     row: 429
     column: 63
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 429
+      column: 60
+    end_location:
+      row: 429
+      column: 60
 - kind: EndsInPunctuation
   location:
     row: 470
@@ -57,7 +99,14 @@ expression: checks
   end_location:
     row: 470
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 470
+      column: 21
+    end_location:
+      row: 470
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 475
@@ -65,7 +114,14 @@ expression: checks
   end_location:
     row: 475
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 475
+      column: 21
+    end_location:
+      row: 475
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 480
@@ -73,7 +129,14 @@ expression: checks
   end_location:
     row: 480
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 480
+      column: 21
+    end_location:
+      row: 480
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 487
@@ -81,7 +144,14 @@ expression: checks
   end_location:
     row: 487
     column: 24
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 487
+      column: 21
+    end_location:
+      row: 487
+      column: 21
 - kind: EndsInPunctuation
   location:
     row: 509
@@ -89,7 +159,14 @@ expression: checks
   end_location:
     row: 509
     column: 34
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 509
+      column: 31
+    end_location:
+      row: 509
+      column: 31
 - kind: EndsInPunctuation
   location:
     row: 520
@@ -97,5 +174,27 @@ expression: checks
   end_location:
     row: 520
     column: 32
-  fix: ~
+  fix:
+    content: "."
+    location:
+      row: 520
+      column: 29
+    end_location:
+      row: 520
+      column: 29
+- kind: EndsInPunctuation
+  location:
+    row: 581
+    column: 4
+  end_location:
+    row: 581
+    column: 51
+  fix:
+    content: "."
+    location:
+      row: 581
+      column: 47
+    end_location:
+      row: 581
+      column: 47
 

src/pyflakes/cformat.rs

@@ -25,29 +25,30 @@ impl TryFrom<&str> for CFormatSummary {
         let mut keywords = FxHashSet::default();
 
         for format_part in format_string.parts {
-            if let CFormatPart::Spec(CFormatSpec {
+            let CFormatPart::Spec(CFormatSpec {
                 mapping_key,
                 min_field_width,
                 precision,
                 ..
-            }) = format_part.1
+            }) = format_part.1 else
             {
-                match mapping_key {
-                    Some(k) => {
-                        keywords.insert(k);
-                    }
-                    None => {
-                        num_positional += 1;
-                    }
-                };
-                if min_field_width == Some(CFormatQuantity::FromValuesTuple) {
-                    num_positional += 1;
-                    starred = true;
+                continue;
+            };
+            match mapping_key {
+                Some(k) => {
+                    keywords.insert(k);
                 }
-                if precision == Some(CFormatQuantity::FromValuesTuple) {
+                None => {
                     num_positional += 1;
-                    starred = true;
                 }
+            };
+            if min_field_width == Some(CFormatQuantity::FromValuesTuple) {
+                num_positional += 1;
+                starred = true;
+            }
+            if precision == Some(CFormatQuantity::FromValuesTuple) {
+                num_positional += 1;
+                starred = true;
             }
         }