Bump version to 0.0.166

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.163
+    rev: v0.0.166
     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.163-dev.0"
+version = "0.0.166-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.163"
+version = "0.0.166"
 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.163"
+version = "0.0.166"
 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.163"
+version = "0.0.166"
 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" }

README.md

@@ -91,7 +91,7 @@ of [Conda](https://docs.conda.io/en/latest/):
    1. [flake8-tidy-imports (I25)](#flake8-tidy-imports)
    1. [eradicate (ERA)](#eradicate)
    1. [pygrep-hooks (PGH)](#pygrep-hooks)
-   1. [Pylint (PL)](#pylint)
+   1. [Pylint (PLC, PLE, PLR, PLW)](#pylint)
    1. [Ruff-specific rules (RUF)](#ruff-specific-rules)
 1. [Editor Integrations](#editor-integrations)
 1. [FAQ](#faq)
@@ -145,7 +145,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.163
+    rev: v0.0.166
     hooks:
       - id: ruff
 ```
@@ -195,6 +195,13 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 # Assume Python 3.10.
 target-version = "py310"
 
+[tool.ruff.flake8-import-conventions.aliases]
+altair = "alt"
+"matplotlib.pyplot" = "plt"
+numpy = "np"
+pandas = "pd"
+seaborn = "sns"
+
 [tool.ruff.mccabe]
 # Unlike Flake8, default to a complexity level of 10.
 max-complexity = 10
@@ -786,6 +793,12 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 | PLR1722 | ConsiderUsingSysExit | Consider using `sys.exit()` | 🛠 |
 | PLW0120 | UselessElseOnLoop | Else clause on loop without a break statement, remove the else and de-indent all the code inside it |  |
 
+### flake8-import-conventions
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| ICN001 | ImportAliasIsNotConventional | `...` should be imported as `...` |  |
+
 ### Ruff-specific rules
 
 | Code | Name | Message | Fix |
@@ -940,6 +953,7 @@ natively, including:
 - [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-eradicate`](https://pypi.org/project/flake8-eradicate/)
+- [`flake8-import-conventions`](https://github.com/joaopalmeiro/flake8-import-conventions)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-return`](https://pypi.org/project/flake8-return/)
@@ -988,6 +1002,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-eradicate`](https://pypi.org/project/flake8-eradicate/)
+- [`flake8-import-conventions`](https://github.com/joaopalmeiro/flake8-import-conventions)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-return`](https://pypi.org/project/flake8-return/)
@@ -1280,6 +1295,49 @@ Summary
 
 ### Options
 
+<!-- Sections automatically generated by `cargo dev generate-options`. -->
+<!-- Begin auto-generated options sections. -->
+
+#### [`allowed-confusables`](#allowed-confusables)
+
+A list of allowed "confusable" Unicode characters to ignore when enforcing `RUF001`,
+`RUF002`, and `RUF003`.
+
+**Default value**: `[]`
+
+**Type**: `Vec<char>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Allow minus-sign (U+2212), greek-small-letter-rho (U+03C1), and the asterisk-operator (U+2217),
+# which could be confused for "-", "p", and "*", respectively.
+allowed-confusables = ["−", "ρ", "∗"]
+```
+
+---
+
+#### [`dummy-variable-rgx`](#dummy-variable-rgx)
+
+A regular expression used to identify "dummy" variables, or those which should be
+ignored when evaluating (e.g.) unused-variable checks. The default expression matches
+`_`, `__`, and `_var`, but not `_var_`.
+
+**Default value**: `"^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"`
+
+**Type**: `Regex`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Only ignore variables named "_".
+dummy_variable_rgx = "^_$"
+```
+
+---
+
 #### [`exclude`](#exclude)
 
 A list of file patterns to exclude from linting.
@@ -1293,8 +1351,8 @@ Exclusions are based on globs, and can be either:
   (to exclude any Python files in `directory`). Note that these paths are relative to the
   project root (e.g., the directory containing your `pyproject.toml`).
 
-Note that you'll typically want to use [`extend-exclude`](#extend-exclude) to modify the excluded
-paths.
+Note that you'll typically want to use [`extend_exclude`](#extend_exclude) to modify
+the excluded paths.
 
 **Default value**: `[".bzr", ".direnv", ".eggs", ".git", ".hg", ".mypy_cache", ".nox", ".pants.d", ".ruff_cache", ".svn", ".tox", ".venv", "__pypackages__", "_build", "buck-out", "build", "dist", "node_modules", "venv"]`
 
@@ -1327,28 +1385,6 @@ extend-exclude = ["tests", "src/bad.py"]
 
 ---
 
-#### [`ignore`](#ignore)
-
-A list of check code prefixes to ignore. Prefixes can specify exact checks (like `F841`), entire
-categories (like `F`), or anything in between.
-
-When breaking ties between enabled and disabled checks (via `select` and `ignore`, respectively),
-more specific prefixes override less specific prefixes.
-
-**Default value**: `[]`
-
-**Type**: `Vec<CheckCodePrefix>`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-# Skip unused variable checks (`F841`).
-ignore = ["F841"]
-```
-
----
-
 #### [`extend-ignore`](#extend-ignore)
 
 A list of check code prefixes to ignore, in addition to those specified by `ignore`.
@@ -1367,28 +1403,6 @@ extend-ignore = ["F841"]
 
 ---
 
-#### [`select`](#select)
-
-A list of check code prefixes to enable. Prefixes can specify exact checks (like `F841`), entire
-categories (like `F`), or anything in between.
-
-When breaking ties between enabled and disabled checks (via `select` and `ignore`, respectively),
-more specific prefixes override less specific prefixes.
-
-**Default value**: `["E", "F"]`
-
-**Type**: `Vec<CheckCodePrefix>`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-# On top of the defaults (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
-select = ["E", "F", "B", "Q"]
-```
-
----
-
 #### [`extend-select`](#extend-select)
 
 A list of check code prefixes to enable, in addition to those specified by `select`.
@@ -1421,8 +1435,8 @@ yet implemented in Ruff.
 
 ```toml
 [tool.ruff]
-# Avoiding flagging (and removing) `V101` from any `# noqa` directives, despite Ruff's lack of
-# support for `vulture`.
+# Avoiding flagging (and removing) `V101` from any `# noqa`
+# directives, despite Ruff's lack of support for `vulture`.
 external = ["V101"]
 ```
 
@@ -1430,8 +1444,8 @@ external = ["V101"]
 
 #### [`fix`](#fix)
 
-Enable autofix behavior by-default when running `ruff` (overridden by the `--fix` and `--no-fix`
-command-line flags).
+Enable autofix behavior by-default when running `ruff` (overridden
+by the `--fix` and `--no-fix` command-line flags).
 
 **Default value**: `false`
 
@@ -1464,9 +1478,33 @@ fixable = ["E", "F"]
 
 ---
 
-#### [`unfixable`](#unfixable)
+#### [`format`](#format)
 
-A list of check code prefixes to consider un-autofix-able.
+The style in which violation messages should be formatted: `"text"` (default),
+`"grouped"` (group messages by file), `"json"` (machine-readable), `"junit"`
+(machine-readable XML), or `"github"` (GitHub Actions annotations).
+
+**Default value**: `"text"`
+
+**Type**: `SerializationType`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Group violations by containing file.
+format = "grouped"
+```
+
+---
+
+#### [`ignore`](#ignore)
+
+A list of check code prefixes to ignore. Prefixes can specify exact checks (like
+`F841`), entire categories (like `F`), or anything in between.
+
+When breaking ties between enabled and disabled checks (via `select` and `ignore`,
+respectively), more specific prefixes override less specific prefixes.
 
 **Default value**: `[]`
 
@@ -1476,8 +1514,28 @@ A list of check code prefixes to consider un-autofix-able.
 
 ```toml
 [tool.ruff]
-# Disable autofix for unused imports (`F401`).
-unfixable = ["F401"]
+# Skip unused variable checks (`F841`).
+ignore = ["F841"]
+```
+
+---
+
+#### [`ignore-init-module-imports`](#ignore-init-module-imports)
+
+Avoid automatically removing unused imports in `__init__.py` files. Such imports will
+still be +flagged, but with a dedicated message suggesting that the import is either
+added to the module' +`__all__` symbol, or re-exported with a redundant alias (e.g.,
+`import os as os`).
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+ignore-init-module-imports = true
 ```
 
 ---
@@ -1500,87 +1558,10 @@ line-length = 120
 
 ---
 
-#### [`dummy-variable-rgx`](#dummy-variable-rgx)
-
-A regular expression used to identify "dummy" variables, or those which should be ignored when evaluating
-(e.g.) unused-variable checks.
-
-**Default value**: `"^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"` (matches `_`, `__`, and `_var`, but not `_var_`)
-
-**Type**: `Regex`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-# Only ignore variables named "_".
-dummy-variable-rgx = "^_$"
-```
-
----
-
-#### [`allowed-confusables`](#allowed-confusables)
-
-A list of allowed "confusable" Unicode characters to ignore when enforcing `RUF001`, `RUF002`,
-and `RUF003`.
-
-**Default value**: `[]`
-
-**Type**: `Vec<char>`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-# Allow minus-sign (U+2212), greek-small-letter-rho (U+03C1), and greek-small-letter-alpha (U+03B1),
-# which could be confused for "-", "p", and "*", respectively.
-allowed-confusables = ["−", "ρ", "∗"]
-```
-
----
-
-#### [`ignore-init-module-imports`](#ignore-init-module-imports)
-
-Avoid automatically removing unused imports in `__init__.py` files. Such imports will still be
-flagged, but with a dedicated message suggesting that the import is either added to the module's
-`__all__` symbol, or re-exported with a redundant alias (e.g., `import os as os`).
-
-**Default value**: `false`
-
-**Type**: `bool`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-ignore-init-module-imports = true
-```
-
----
-
-#### [`format`](#format)
-
-The style in which violation messages should be formatted: `"text"` (default), `"grouped"`
-(group messages by file), `"json"` (machine-readable), `"junit"` (machine-readable XML), or `"github"` (GitHub Actions annotations).
-
-**Default value**: `"text"`
-
-**Type**: `SerializationFormat`
-
-**Example usage**:
-
-```toml
-[tool.ruff]
-# Group violations by containing file.
-format = "grouped"
-```
-
----
-
 #### [`per-file-ignores`](#per-file-ignores)
 
-A list of mappings from file pattern to check code prefixes to exclude, when considering any
-matching files.
+A list of mappings from file pattern to check code prefixes to exclude, when considering
+any matching files.
 
 **Default value**: `{}`
 
@@ -1598,10 +1579,32 @@ matching files.
 
 ---
 
+#### [`select`](#select)
+
+A list of check code prefixes to enable. Prefixes can specify exact checks (like
+`F841`), entire categories (like `F`), or anything in between.
+
+When breaking ties between enabled and disabled checks (via `select` and `ignore`,
+respectively), more specific prefixes override less specific prefixes.
+
+**Default value**: `["E", "F"]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# On top of the defaults (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
+select = ["E", "F", "B", "Q"]
+```
+
+---
+
 #### [`show-source`](#show-source)
 
-Whether to show source code snippets when reporting lint error violations (overridden by the
-`--show-source` command-line flag).
+Whether to show source code snippets when reporting lint error violations (overridden by
+the `--show-source` command-line flag).
 
 **Default value**: `false`
 
@@ -1637,9 +1640,9 @@ src = ["src", "test"]
 
 #### [`target-version`](#target-version)
 
-The Python version to target, e.g., when considering automatic code upgrades, like rewriting type
-annotations. Note that the target version will _not_ be inferred from the _current_ Python version,
-and instead must be specified explicitly (as seen below).
+The Python version to target, e.g., when considering automatic code upgrades, like
+rewriting type annotations. Note that the target version will _not_ be inferred from the
+_current_ Python version, and instead must be specified explicitly (as seen below).
 
 **Default value**: `"py310"`
 
@@ -1653,12 +1656,49 @@ and instead must be specified explicitly (as seen below).
 target-version = "py37"
 ```
 
+---
+
+#### [`unfixable`](#unfixable)
+
+A list of check code prefixes to consider un-autofix-able.
+
+**Default value**: `[]`
+
+**Type**: `Vec<CheckCodePrefix>`
+
+**Example usage**:
+
+```toml
+[tool.ruff]
+# Disable autofix for unused imports (`F401`).
+unfixable = ["F401"]
+```
+
+---
+
 ### `flake8-annotations`
 
+#### [`allow-star-arg-any`](#allow-star-arg-any)
+
+Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` arguments.
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-annotations]
+allow-star-arg-any = true
+```
+
+---
+
 #### [`mypy-init-return`](#mypy-init-return)
 
-Whether to allow the omission of a return type hint for `__init__` if at least one argument is
-annotated.
+Whether to allow the omission of a return type hint for `__init__` if at least one
+argument is annotated.
 
 **Default value**: `false`
 
@@ -1675,8 +1715,8 @@ mypy-init-return = true
 
 #### [`suppress-dummy-args`](#suppress-dummy-args)
 
-Whether to suppress `ANN000`-level errors for arguments matching the "dummy" variable regex (like
-`_`).
+Whether to suppress `ANN000`-level errors for arguments matching the "dummy" variable
+regex (like `_`).
 
 **Default value**: `false`
 
@@ -1693,7 +1733,8 @@ suppress-dummy-args = true
 
 #### [`suppress-none-returning`](#suppress-none-returning)
 
-Whether to suppress `ANN200`-level errors for functions that meet either of the following criteria:
+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).
@@ -1711,27 +1752,12 @@ suppress-none-returning = true
 
 ---
 
-#### [`allow-star-arg-any`](#allow-star-arg-any)
-
-Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` arguments.
-
-**Default value**: `false`
-
-**Type**: `bool`
-
-**Example usage**:
-
-```toml
-[tool.ruff.flake8-annotations]
-allow-star-arg-any = true
-```
-
 ### `flake8-bugbear`
 
 #### [`extend-immutable-calls`](#extend-immutable-calls)
 
-Additional callable functions to consider "immutable" when evaluating, e.g., no-mutable-default-argument
-checks (`B006`).
+Additional callable functions to consider "immutable" when evaluating, e.g.,
+`no-mutable-default-argument` checks (`B006`).
 
 **Default value**: `[]`
 
@@ -1745,8 +1771,89 @@ checks (`B006`).
 extend-immutable-calls = ["fastapi.Depends", "fastapi.Query"]
 ```
 
+---
+
+### `flake8-import-conventions`
+
+#### [`aliases`](#aliases)
+
+The conventional aliases for imports. These aliases can be extended by the `extend_aliases` option.
+
+**Default value**: `{"altair": "alt", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns"}`
+
+**Type**: `FxHashMap<String, String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-import-conventions]
+# Declare the default aliases.
+altair = "alt"
+matplotlib.pyplot = "plt"
+numpy = "np"
+pandas = "pd"
+seaborn = "sns"
+```
+
+---
+
+#### [`extend-aliases`](#extend-aliases)
+
+A mapping of modules to their conventional import aliases. These aliases will be added to the `aliases` mapping.
+
+**Default value**: `{}`
+
+**Type**: `FxHashMap<String, String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-import-conventions]
+# Declare a custom alias for the `matplotlib` module.
+"dask.dataframe" = "dd"
+```
+
+---
+
 ### `flake8-quotes`
 
+#### [`avoid-escape`](#avoid-escape)
+
+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 value**: `true`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+# Don't bother trying to avoid escapes.
+avoid-escape = false
+```
+
+---
+
+#### [`docstring-quotes`](#docstring-quotes)
+
+Quote style to prefer for docstrings (either "single" (`'`) or "double" (`"`)).
+
+**Default value**: `"double"`
+
+**Type**: `Quote`
+
+**Example usage**:
+
+```toml
+[tool.ruff.flake8-quotes]
+docstring-quotes = "single"
+```
+
+---
+
 #### [`inline-quotes`](#inline-quotes)
 
 Quote style to prefer for inline strings (either "single" (`'`) or "double" (`"`)).
@@ -1781,47 +1888,12 @@ multiline-quotes = "single"
 
 ---
 
-#### [`docstring-quotes`](#docstring-quotes)
-
-Quote style to prefer for docstrings (either "single" (`'`) or "double" (`"`)).
-
-**Default value**: `"double"`
-
-**Type**: `Quote`
-
-**Example usage**:
-
-```toml
-[tool.ruff.flake8-quotes]
-docstring-quotes = "single"
-```
-
----
-
-#### [`avoid-escape`](#avoid-escape)
-
-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 value**: `true`
-
-**Type**: `bool`
-
-**Example usage**:
-
-```toml
-[tool.ruff.flake8-quotes]
-# Don't bother trying to avoid escapes.
-avoid-escape = false
-```
-
 ### `flake8-tidy-imports`
 
 #### [`ban-relative-imports`](#ban-relative-imports)
 
-Whether to ban all relative imports (`"all"`), or only those imports that extend into the parent
-module and beyond (`"parents"`).
+Whether to ban all relative imports (`"all"`), or only those imports that extend into
+the parent module and beyond (`"parents"`).
 
 **Default value**: `"parents"`
 
@@ -1835,61 +1907,10 @@ module and beyond (`"parents"`).
 ban-relative-imports = "all"
 ```
 
+---
+
 ### `isort`
 
-#### [`known-first-party`](#known-first-party)
-
-A list of modules to consider first-party, regardless of whether they can be identified as such
-via introspection of the local filesystem.
-
-**Default value**: `[]`
-
-**Type**: `Vec<String>`
-
-**Example usage**:
-
-```toml
-[tool.ruff.isort]
-known-first-party = ["src"]
-```
-
----
-
-#### [`known-third-party`](#known-third-party)
-
-A list of modules to consider third-party, regardless of whether they can be identified as such
-via introspection of the local filesystem.
-
-**Default value**: `[]`
-
-**Type**: `Vec<String>`
-
-**Example usage**:
-
-```toml
-[tool.ruff.isort]
-known-third-party = ["fastapi"]
-```
-
----
-
-#### [`extra-standard-library`](#extra-standard-library)
-
-A list of modules to consider standard-library, in addition to those known to Ruff in advance.
-
-**Default value**: `[]`
-
-**Type**: `Vec<String>`
-
-**Example usage**:
-
-```toml
-[tool.ruff.isort]
-extra-standard-library = ["path"]
-```
-
----
-
 #### [`combine-as-imports`](#combine-as-imports)
 
 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)
@@ -1908,11 +1929,29 @@ combine-as-imports = true
 
 ---
 
+#### [`extra-standard-library`](#extra-standard-library)
+
+A list of modules to consider standard-library, in addition to those known to Ruff in
+advance.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+extra-standard-library = ["path"]
+```
+
+---
+
 #### [`force-wrap-aliases`](#force-wrap-aliases)
 
-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:
+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 (
@@ -1932,6 +1971,44 @@ from .utils import (
 force-wrap-aliases = true
 ```
 
+---
+
+#### [`known-first-party`](#known-first-party)
+
+A list of modules to consider first-party, regardless of whether they can be identified
+as such via introspection of the local filesystem.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+known-first-party = ["src"]
+```
+
+---
+
+#### [`known-third-party`](#known-third-party)
+
+A list of modules to consider third-party, regardless of whether they can be identified
+as such via introspection of the local filesystem.
+
+**Default value**: `[]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+known-third-party = ["src"]
+```
+
+---
+
 ### `mccabe`
 
 #### [`max-complexity`](#max-complexity)
@@ -1950,8 +2027,30 @@ The maximum McCabe complexity to allow before triggering `C901` errors.
 max-complexity = 5
 ```
 
+---
+
 ### `pep8-naming`
 
+#### [`classmethod-decorators`](#classmethod-decorators)
+
+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 value**: `["classmethod"]`
+
+**Type**: `Vec<String>`
+
+**Example usage**:
+
+```toml
+[tool.ruff.pep8-naming]
+# Allow Pydantic's `@validator` decorator to trigger class method treatment.
+classmethod-decorators = ["classmethod", "pydantic.validator"]
+```
+
+---
+
 #### [`ignore-names`](#ignore-names)
 
 A list of names to ignore when considering `pep8-naming` violations.
@@ -1969,31 +2068,11 @@ ignore-names = ["callMethod"]
 
 ---
 
-#### [`classmethod-decorators`](#classmethod-decorators)
-
-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 value**: `["classmethod"]`
-
-**Type**: `Vec<String>`
-
-**Example usage**:
-
-```toml
-[tool.ruff.pep8-naming]
-# Allow Pydantic's `@validator` decorator to trigger class method treatment.
-classmethod-decorators = ["classmethod", "pydantic.validator"]
-```
-
----
-
 #### [`staticmethod-decorators`](#staticmethod-decorators)
 
-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.
+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 value**: `["staticmethod"]`
 
@@ -2007,13 +2086,13 @@ has no `self` or `cls` argument.
 staticmethod-decorators = ["staticmethod", "stcmthd"]
 ```
 
+---
+
 ### `pyupgrade`
 
 #### [`keep-runtime-typing`](#keep-runtime-typing)
 
-Whether to avoid PEP 585 (`List[int]` -> `list[int]`) and PEP 604 (`Optional[str]` -> `str | None`)
-rewrites even if a file imports `from __future__ import annotations`. Note that this setting is
-only applicable when the target Python version is below 3.9 and 3.10 respectively.
+Whether to avoid PEP 585 (`List[int]` -> `list[int]`) and PEP 604 (`Optional[str]` -> `str | None`) rewrites even if a file imports `from __future__ import annotations`. Note that this setting is only applicable when the target Python version is below 3.9 and 3.10 respectively.
 
 **Default value**: `false`
 
@@ -2027,6 +2106,10 @@ only applicable when the target Python version is below 3.9 and 3.10 respectivel
 keep-runtime-typing = true
 ```
 
+---
+
+<!-- End auto-generated options sections. -->
+
 ## License
 
 MIT

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

flake8_to_ruff/src/converter.rs

@@ -270,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,
@@ -314,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,
@@ -358,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,
@@ -402,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,
@@ -451,6 +455,7 @@ mod tests {
                 avoid_escape: None,
             }),
             flake8_tidy_imports: None,
+            flake8_import_conventions: None,
             isort: None,
             mccabe: None,
             pep8_naming: None,
@@ -533,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,
@@ -583,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_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/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

@@ -41,3 +41,9 @@ 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"

ruff_dev/Cargo.toml

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

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/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/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>;

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,
@@ -730,6 +727,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 {
@@ -2485,13 +2495,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 +2801,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 +3145,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 +3161,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_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

@@ -290,6 +290,8 @@ pub enum CheckCode {
     FBT001,
     FBT002,
     FBT003,
+    // flake8-import-conventions
+    ICN001,
     // Ruff
     RUF001,
     RUF002,
@@ -324,6 +326,7 @@ pub enum CheckCategory {
     Eradicate,
     PygrepHooks,
     Pylint,
+    ImportConventions,
     Ruff,
 }
 
@@ -367,6 +370,7 @@ impl CheckCategory {
             CheckCategory::PygrepHooks => "pygrep-hooks",
             CheckCategory::Pylint => "Pylint",
             CheckCategory::Pyupgrade => "pyupgrade",
+            CheckCategory::ImportConventions => "flake8-import-conventions",
             CheckCategory::Ruff => "Ruff-specific rules",
         }
     }
@@ -459,6 +463,7 @@ impl CheckCategory {
             CheckCategory::Pyupgrade => {
                 Some(("https://pypi.org/project/pyupgrade/3.2.0/", &Platform::PyPI))
             }
+            CheckCategory::ImportConventions => None,
             CheckCategory::Ruff => None,
         }
     }
@@ -774,6 +779,8 @@ pub enum CheckKind {
     BooleanPositionalValueInFunctionCall,
     // pygrep-hooks
     NoEval,
+    // flake8-import-conventions
+    ImportAliasIsNotConventional(String, String),
     // Ruff
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
@@ -1113,6 +1120,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'),
@@ -1365,6 +1376,7 @@ impl CheckCode {
             CheckCode::YTT301 => CheckCategory::Flake82020,
             CheckCode::YTT302 => CheckCategory::Flake82020,
             CheckCode::YTT303 => CheckCategory::Flake82020,
+            CheckCode::ICN001 => CheckCategory::ImportConventions,
         }
     }
 }
@@ -1633,6 +1645,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,
@@ -2419,6 +2433,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!(

src/checks_gen.rs

@@ -256,6 +256,10 @@ pub enum CheckCodePrefix {
     I2,
     I25,
     I252,
+    ICN,
+    ICN0,
+    ICN00,
+    ICN001,
     N,
     N8,
     N80,
@@ -1138,6 +1142,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,
@@ -1907,6 +1915,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 +2099,7 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::F,
     CheckCodePrefix::FBT,
     CheckCodePrefix::I,
+    CheckCodePrefix::ICN,
     CheckCodePrefix::N,
     CheckCodePrefix::PGH,
     CheckCodePrefix::PLC,

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_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_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/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/track.rs

@@ -23,6 +23,7 @@ pub struct ImportTracker<'a> {
     blocks: Vec<Block<'a>>,
     directives: &'a IsortDirectives,
     split_index: usize,
+    nested: bool,
 }
 
 impl<'a> ImportTracker<'a> {
@@ -31,6 +32,7 @@ impl<'a> ImportTracker<'a> {
             directives,
             blocks: vec![Block::default()],
             split_index: 0,
+            nested: false,
         }
     }
 
@@ -60,8 +62,9 @@ where
         // Track manual splits.
         while self.split_index < self.directives.splits.len() {
             if stmt.location.row() >= self.directives.splits[self.split_index] {
-                // TODO(charlie): Track nesting semantically, rather than via column index.
-                self.finalize(Some(if stmt.location.column() == 0 {
+                self.finalize(Some(if self.nested {
+                    Trailer::Sibling
+                } else {
                     match &stmt.node {
                         StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
                             Trailer::FunctionDef
@@ -69,8 +72,6 @@ where
                         StmtKind::ClassDef { .. } => Trailer::ClassDef,
                         _ => Trailer::Sibling,
                     }
-                } else {
-                    Trailer::Sibling
                 }));
                 self.split_index += 1;
             } else {
@@ -86,8 +87,9 @@ where
         {
             self.track_import(stmt);
         } else {
-            // TODO(charlie): Track nesting semantically, rather than via column index.
-            self.finalize(Some(if stmt.location.column() == 0 {
+            self.finalize(Some(if self.nested {
+                Trailer::Sibling
+            } else {
                 match &stmt.node {
                     StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
                         Trailer::FunctionDef
@@ -95,12 +97,12 @@ where
                     StmtKind::ClassDef { .. } => Trailer::ClassDef,
                     _ => Trailer::Sibling,
                 }
-            } else {
-                Trailer::Sibling
             }));
         }
 
         // Track scope.
+        let prev_nested = self.nested;
+        self.nested = true;
         match &stmt.node {
             StmtKind::FunctionDef { body, .. } => {
                 for stmt in body {
@@ -208,6 +210,7 @@ where
             }
             _ => {}
         }
+        self.nested = prev_nested;
     }
 
     fn visit_annotation(&mut self, _: &'b Expr) {}
@@ -229,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(None);
+
+        self.nested = prev_nested;
     }
 
     fn visit_arguments(&mut self, _: &'b Arguments) {}

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/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/pyflakes/mod.rs

@@ -71,7 +71,8 @@ mod tests {
     #[test_case(CheckCode::F822, Path::new("F822.py"); "F822")]
     #[test_case(CheckCode::F823, Path::new("F823.py"); "F823")]
     #[test_case(CheckCode::F831, Path::new("F831.py"); "F831")]
-    #[test_case(CheckCode::F841, Path::new("F841.py"); "F841")]
+    #[test_case(CheckCode::F841, Path::new("F841_0.py"); "F841_0")]
+    #[test_case(CheckCode::F841, Path::new("F841_1.py"); "F841_1")]
     #[test_case(CheckCode::F901, Path::new("F901.py"); "F901")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
@@ -90,7 +91,7 @@ mod tests {
     #[test]
     fn f841_dummy_variable_rgx() -> Result<()> {
         let mut checks = test_path(
-            Path::new("./resources/test/fixtures/pyflakes/F841.py"),
+            Path::new("./resources/test/fixtures/pyflakes/F841_0.py"),
             &settings::Settings {
                 dummy_variable_rgx: Regex::new(r"^z$").unwrap(),
                 ..settings::Settings::for_rule(CheckCode::F841)

src/pyflakes/snapshots/ruff__pyflakes__tests__F841_F841_0.py.snap

@@ -47,6 +47,15 @@ expression: checks
     row: 21
     column: 9
   fix: ~
+- kind:
+    UnusedVariable: baz
+  location:
+    row: 26
+    column: 13
+  end_location:
+    row: 26
+    column: 16
+  fix: ~
 - kind:
     UnusedVariable: b
   location:
@@ -56,4 +65,13 @@ expression: checks
     row: 51
     column: 9
   fix: ~
+- kind:
+    UnusedVariable: f
+  location:
+    row: 71
+    column: 25
+  end_location:
+    row: 71
+    column: 26
+  fix: ~
 

src/pyflakes/snapshots/ruff__pyflakes__tests__F841_F841_1.py.snap

@@ -0,0 +1,77 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    UnusedVariable: x
+  location:
+    row: 6
+    column: 4
+  end_location:
+    row: 6
+    column: 5
+  fix: ~
+- kind:
+    UnusedVariable: y
+  location:
+    row: 6
+    column: 7
+  end_location:
+    row: 6
+    column: 8
+  fix: ~
+- kind:
+    UnusedVariable: coords
+  location:
+    row: 16
+    column: 13
+  end_location:
+    row: 16
+    column: 19
+  fix: ~
+- kind:
+    UnusedVariable: coords
+  location:
+    row: 20
+    column: 4
+  end_location:
+    row: 20
+    column: 10
+  fix: ~
+- kind:
+    UnusedVariable: a
+  location:
+    row: 24
+    column: 5
+  end_location:
+    row: 24
+    column: 6
+  fix: ~
+- kind:
+    UnusedVariable: b
+  location:
+    row: 24
+    column: 8
+  end_location:
+    row: 24
+    column: 9
+  fix: ~
+- kind:
+    UnusedVariable: x
+  location:
+    row: 24
+    column: 14
+  end_location:
+    row: 24
+    column: 15
+  fix: ~
+- kind:
+    UnusedVariable: y
+  location:
+    row: 24
+    column: 17
+  end_location:
+    row: 24
+    column: 18
+  fix: ~
+

src/pyflakes/snapshots/ruff__pyflakes__tests__f841_dummy_variable_rgx.snap

@@ -38,6 +38,15 @@ expression: checks
     row: 21
     column: 9
   fix: ~
+- kind:
+    UnusedVariable: baz
+  location:
+    row: 26
+    column: 13
+  end_location:
+    row: 26
+    column: 16
+  fix: ~
 - kind:
     UnusedVariable: _
   location:
@@ -74,4 +83,13 @@ expression: checks
     row: 51
     column: 9
   fix: ~
+- kind:
+    UnusedVariable: f
+  location:
+    row: 71
+    column: 25
+  end_location:
+    row: 71
+    column: 26
+  fix: ~
 

src/pyupgrade/settings.rs

@@ -1,10 +1,22 @@
 //! Settings for the `pyupgrade` 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#"
+            Whether to avoid PEP 585 (`List[int]` -> `list[int]`) and PEP 604 (`Optional[str]` -> `str | None`) rewrites even if a file imports `from __future__ import annotations`. Note that this setting is only applicable when the target Python version is below 3.9 and 3.10 respectively.
+        "#,
+        default = r#"false"#,
+        value_type = "bool",
+        example = r#"
+            # Preserve types, even if a file imports `from __future__ import annotations`.
+            keep-runtime-typing = true
+        "#
+    )]
     pub keep_runtime_typing: Option<bool>,
 }
 

src/ruff/snapshots/ruff__ruff__tests__confusables.snap

@@ -0,0 +1,59 @@
+---
+source: src/ruff/mod.rs
+expression: checks
+---
+- kind:
+    AmbiguousUnicodeCharacterString:
+      - 𝐁
+      - B
+  location:
+    row: 1
+    column: 5
+  end_location:
+    row: 1
+    column: 6
+  fix:
+    content: B
+    location:
+      row: 1
+      column: 5
+    end_location:
+      row: 1
+      column: 6
+- kind:
+    AmbiguousUnicodeCharacterDocstring:
+      - ）
+      - )
+  location:
+    row: 6
+    column: 55
+  end_location:
+    row: 6
+    column: 56
+  fix:
+    content: )
+    location:
+      row: 6
+      column: 55
+    end_location:
+      row: 6
+      column: 56
+- kind:
+    AmbiguousUnicodeCharacterComment:
+      - ᜵
+      - /
+  location:
+    row: 7
+    column: 61
+  end_location:
+    row: 7
+    column: 62
+  fix:
+    content: /
+    location:
+      row: 7
+      column: 61
+    end_location:
+      row: 7
+      column: 62
+

src/ruff/snapshots/ruff__ruff__tests__flake8_noqa.snap

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

src/ruff/snapshots/ruff__ruff__tests__redirects.snap

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

src/ruff/snapshots/ruff__ruff__tests__ruf100.snap

@@ -0,0 +1,185 @@
+---
+source: src/ruff/mod.rs
+expression: checks
+---
+- kind:
+    UnusedNOQA: ~
+  location:
+    row: 9
+    column: 11
+  end_location:
+    row: 9
+    column: 17
+  fix:
+    content: ""
+    location:
+      row: 9
+      column: 9
+    end_location:
+      row: 9
+      column: 17
+- kind:
+    UnusedNOQA:
+      - E501
+  location:
+    row: 13
+    column: 11
+  end_location:
+    row: 13
+    column: 23
+  fix:
+    content: ""
+    location:
+      row: 13
+      column: 9
+    end_location:
+      row: 13
+      column: 23
+- kind:
+    UnusedNOQA:
+      - F841
+      - E501
+  location:
+    row: 16
+    column: 11
+  end_location:
+    row: 16
+    column: 29
+  fix:
+    content: ""
+    location:
+      row: 16
+      column: 9
+    end_location:
+      row: 16
+      column: 29
+- kind:
+    UnusedNOQA:
+      - F841
+      - W191
+  location:
+    row: 19
+    column: 11
+  end_location:
+    row: 19
+    column: 29
+  fix:
+    content: ""
+    location:
+      row: 19
+      column: 9
+    end_location:
+      row: 19
+      column: 29
+- kind:
+    UnusedNOQA:
+      - F841
+      - V101
+  location:
+    row: 22
+    column: 11
+  end_location:
+    row: 22
+    column: 29
+  fix:
+    content: ""
+    location:
+      row: 22
+      column: 9
+    end_location:
+      row: 22
+      column: 29
+- kind:
+    UnusedNOQA:
+      - E501
+  location:
+    row: 26
+    column: 9
+  end_location:
+    row: 26
+    column: 21
+  fix:
+    content: ""
+    location:
+      row: 26
+      column: 9
+    end_location:
+      row: 26
+      column: 21
+- kind:
+    UnusedVariable: d
+  location:
+    row: 29
+    column: 4
+  end_location:
+    row: 29
+    column: 5
+  fix: ~
+- kind:
+    UnusedNOQA:
+      - E501
+  location:
+    row: 29
+    column: 32
+  end_location:
+    row: 29
+    column: 44
+  fix:
+    content: ""
+    location:
+      row: 29
+      column: 9
+    end_location:
+      row: 29
+      column: 44
+- kind:
+    UnusedNOQA:
+      - F841
+  location:
+    row: 55
+    column: 5
+  end_location:
+    row: 55
+    column: 23
+  fix:
+    content: "# noqa: E501"
+    location:
+      row: 55
+      column: 5
+    end_location:
+      row: 55
+      column: 23
+- kind:
+    UnusedNOQA:
+      - E501
+  location:
+    row: 63
+    column: 5
+  end_location:
+    row: 63
+    column: 17
+  fix:
+    content: ""
+    location:
+      row: 63
+      column: 3
+    end_location:
+      row: 63
+      column: 17
+- kind:
+    UnusedNOQA: ~
+  location:
+    row: 71
+    column: 5
+  end_location:
+    row: 71
+    column: 11
+  fix:
+    content: ""
+    location:
+      row: 71
+      column: 3
+    end_location:
+      row: 71
+      column: 11
+

src/ruff/snapshots/ruff__ruff__tests__ruff_noqa.snap

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

src/settings/configuration.rs

@@ -14,8 +14,8 @@ use crate::checks_gen::{CheckCodePrefix, CATEGORIES};
 use crate::settings::pyproject::load_options;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion, SerializationFormat};
 use crate::{
-    flake8_annotations, flake8_bugbear, flake8_quotes, flake8_tidy_imports, fs, isort, mccabe,
-    pep8_naming, pyupgrade,
+    flake8_annotations, flake8_bugbear, flake8_import_conventions, flake8_quotes,
+    flake8_tidy_imports, fs, isort, mccabe, pep8_naming, pyupgrade,
 };
 
 #[derive(Debug)]
@@ -42,6 +42,7 @@ pub struct Configuration {
     // Plugins
     pub flake8_annotations: flake8_annotations::settings::Settings,
     pub flake8_bugbear: flake8_bugbear::settings::Settings,
+    pub flake8_import_conventions: flake8_import_conventions::settings::Settings,
     pub flake8_quotes: flake8_quotes::settings::Settings,
     pub flake8_tidy_imports: flake8_tidy_imports::settings::Settings,
     pub isort: isort::settings::Settings,
@@ -152,6 +153,10 @@ impl Configuration {
                 .flake8_bugbear
                 .map(flake8_bugbear::settings::Settings::from_options)
                 .unwrap_or_default(),
+            flake8_import_conventions: options
+                .flake8_import_conventions
+                .map(flake8_import_conventions::settings::Settings::from_options)
+                .unwrap_or_default(),
             flake8_quotes: options
                 .flake8_quotes
                 .map(flake8_quotes::settings::Settings::from_options)
@@ -166,6 +171,7 @@ impl Configuration {
                 .unwrap_or_default(),
             mccabe: options
                 .mccabe
+                .as_ref()
                 .map(mccabe::settings::Settings::from_options)
                 .unwrap_or_default(),
             pep8_naming: options

src/settings/mod.rs

@@ -17,12 +17,13 @@ use crate::checks_gen::{CheckCodePrefix, SuffixLength};
 use crate::settings::configuration::Configuration;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion, SerializationFormat};
 use crate::{
-    flake8_annotations, flake8_bugbear, flake8_quotes, flake8_tidy_imports, fs, isort, mccabe,
-    pep8_naming, pyupgrade,
+    flake8_annotations, flake8_bugbear, flake8_import_conventions, flake8_quotes,
+    flake8_tidy_imports, fs, isort, mccabe, pep8_naming, pyupgrade,
 };
 
 pub mod configuration;
 pub mod options;
+pub mod options_base;
 pub mod pyproject;
 pub mod types;
 
@@ -45,6 +46,7 @@ pub struct Settings {
     // Plugins
     pub flake8_annotations: flake8_annotations::settings::Settings,
     pub flake8_bugbear: flake8_bugbear::settings::Settings,
+    pub flake8_import_conventions: flake8_import_conventions::settings::Settings,
     pub flake8_quotes: flake8_quotes::settings::Settings,
     pub flake8_tidy_imports: flake8_tidy_imports::settings::Settings,
     pub isort: isort::settings::Settings,
@@ -80,6 +82,7 @@ impl Settings {
             format: config.format,
             flake8_annotations: config.flake8_annotations,
             flake8_bugbear: config.flake8_bugbear,
+            flake8_import_conventions: config.flake8_import_conventions,
             flake8_quotes: config.flake8_quotes,
             flake8_tidy_imports: config.flake8_tidy_imports,
             ignore_init_module_imports: config.ignore_init_module_imports,
@@ -113,6 +116,7 @@ impl Settings {
             target_version: PythonVersion::Py310,
             flake8_annotations: flake8_annotations::settings::Settings::default(),
             flake8_bugbear: flake8_bugbear::settings::Settings::default(),
+            flake8_import_conventions: flake8_import_conventions::settings::Settings::default(),
             flake8_quotes: flake8_quotes::settings::Settings::default(),
             flake8_tidy_imports: flake8_tidy_imports::settings::Settings::default(),
             isort: isort::settings::Settings::default(),
@@ -140,6 +144,7 @@ impl Settings {
             target_version: PythonVersion::Py310,
             flake8_annotations: flake8_annotations::settings::Settings::default(),
             flake8_bugbear: flake8_bugbear::settings::Settings::default(),
+            flake8_import_conventions: flake8_import_conventions::settings::Settings::default(),
             flake8_quotes: flake8_quotes::settings::Settings::default(),
             flake8_tidy_imports: flake8_tidy_imports::settings::Settings::default(),
             isort: isort::settings::Settings::default(),
@@ -175,6 +180,7 @@ impl Hash for Settings {
         // Add plugin properties in alphabetical order.
         self.flake8_annotations.hash(state);
         self.flake8_bugbear.hash(state);
+        self.flake8_import_conventions.hash(state);
         self.flake8_quotes.hash(state);
         self.flake8_tidy_imports.hash(state);
         self.isort.hash(state);

src/settings/options.rs

@@ -1,45 +1,289 @@
 //! Options that the user can provide via pyproject.toml.
 
+use ruff_macros::ConfigurationOptions;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::checks_gen::CheckCodePrefix;
 use crate::settings::types::{PythonVersion, SerializationFormat};
 use crate::{
-    flake8_annotations, flake8_bugbear, flake8_quotes, flake8_tidy_imports, isort, mccabe,
-    pep8_naming, pyupgrade,
+    flake8_annotations, flake8_bugbear, flake8_import_conventions, flake8_quotes,
+    flake8_tidy_imports, isort, mccabe, pep8_naming, pyupgrade,
 };
 
-#[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 allowed "confusable" Unicode characters to ignore when enforcing `RUF001`,
+            `RUF002`, and `RUF003`.
+        "#,
+        default = r#"[]"#,
+        value_type = "Vec<char>",
+        example = r#"
+            # Allow minus-sign (U+2212), greek-small-letter-rho (U+03C1), and the asterisk-operator (U+2217),
+            # which could be confused for "-", "p", and "*", respectively.
+            allowed-confusables = ["−", "ρ", "∗"]
+        "#
+    )]
     pub allowed_confusables: Option<Vec<char>>,
+    #[option(
+        doc = r#"
+            A regular expression used to identify "dummy" variables, or those which should be
+            ignored when evaluating (e.g.) unused-variable checks. The default expression matches
+            `_`, `__`, and `_var`, but not `_var_`.
+        "#,
+        default = r#""^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$""#,
+        value_type = "Regex",
+        example = r#"
+            # Only ignore variables named "_".
+            dummy_variable_rgx = "^_$"
+        "#
+    )]
     pub dummy_variable_rgx: Option<String>,
+    #[option(
+        doc = r#"
+            A list of file patterns to exclude from linting.
+
+            Exclusions are based on globs, and can be either:
+
+            - Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the
+              tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching
+              `foo_*.py` ).
+            - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py`
+              (to exclude any Python files in `directory`). Note that these paths are relative to the
+              project root (e.g., the directory containing your `pyproject.toml`).
+
+            Note that you'll typically want to use [`extend_exclude`](#extend_exclude) to modify
+            the excluded paths.
+        "#,
+        default = r#"[".bzr", ".direnv", ".eggs", ".git", ".hg", ".mypy_cache", ".nox", ".pants.d", ".ruff_cache", ".svn", ".tox", ".venv", "__pypackages__", "_build", "buck-out", "build", "dist", "node_modules", "venv"]"#,
+        value_type = "Vec<FilePattern>",
+        example = r#"
+            exclude = [".venv"]
+        "#
+    )]
     pub exclude: Option<Vec<String>>,
+    #[option(
+        doc = "A list of file patterns to omit from linting, in addition to those specified by \
+               `exclude`.",
+        default = "[]",
+        value_type = "Vec<FilePattern>",
+        example = r#"
+            # In addition to the standard set of exclusions, omit all tests, plus a specific file.
+            extend-exclude = ["tests", "src/bad.py"]
+        "#
+    )]
     pub extend_exclude: Option<Vec<String>>,
+    #[option(
+        doc = "A list of check code prefixes to ignore, in addition to those specified by \
+               `ignore`.",
+        default = "[]",
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # Skip unused variable checks (`F841`).
+            extend-ignore = ["F841"]
+        "#
+    )]
     pub extend_ignore: Option<Vec<CheckCodePrefix>>,
+    #[option(
+        doc = "A list of check code prefixes to enable, in addition to those specified by \
+               `select`.",
+        default = "[]",
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # On top of the default `select` (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
+            extend-select = ["B", "Q"]
+        "#
+    )]
     pub extend_select: Option<Vec<CheckCodePrefix>>,
+    #[option(
+        doc = r#"
+            A list of check codes that are unsupported by Ruff, but should be preserved when (e.g.)
+            validating `# noqa` directives. Useful for retaining `# noqa` directives that cover plugins not
+            yet implemented in Ruff.
+        "#,
+        default = "[]",
+        value_type = "Vec<String>",
+        example = r#"
+            # Avoiding flagging (and removing) `V101` from any `# noqa`
+            # directives, despite Ruff's lack of support for `vulture`.
+            external = ["V101"]
+        "#
+    )]
     pub external: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            Enable autofix behavior by-default when running `ruff` (overridden
+            by the `--fix` and `--no-fix` command-line flags).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = "fix = true"
+    )]
     pub fix: Option<bool>,
+    #[option(
+        doc = "A list of check code prefixes to consider autofix-able.",
+        default = r#"["A", "ANN", "B", "BLE", "C", "D", "E", "F", "FBT", "I", "M", "N", "Q", "RUF", "S", "T", "U", "W", "YTT"]"#,
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # Only allow autofix behavior for `E` and `F` checks.
+            fixable = ["E", "F"]
+        "#
+    )]
     pub fixable: Option<Vec<CheckCodePrefix>>,
+    #[option(
+        doc = r#"
+            The style in which violation messages should be formatted: `"text"` (default),
+            `"grouped"` (group messages by file), `"json"` (machine-readable), `"junit"`
+            (machine-readable XML), or `"github"` (GitHub Actions annotations).
+        "#,
+        default = r#""text""#,
+        value_type = "SerializationType",
+        example = r#"
+            # Group violations by containing file.
+            format = "grouped"
+        "#
+    )]
     pub format: Option<SerializationFormat>,
+    #[option(
+        doc = r"
+            A list of check code prefixes to ignore. Prefixes can specify exact checks (like
+            `F841`), entire categories (like `F`), or anything in between.
+
+            When breaking ties between enabled and disabled checks (via `select` and `ignore`,
+            respectively), more specific prefixes override less specific prefixes.
+        ",
+        default = "[]",
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # Skip unused variable checks (`F841`).
+            ignore = ["F841"]
+        "#
+    )]
     pub ignore: Option<Vec<CheckCodePrefix>>,
+    #[option(
+        doc = r#"
+            Avoid automatically removing unused imports in `__init__.py` files. Such imports will
+            still be +flagged, but with a dedicated message suggesting that the import is either
+            added to the module' +`__all__` symbol, or re-exported with a redundant alias (e.g.,
+            `import os as os`).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = r#"
+            ignore-init-module-imports = true
+        "#
+    )]
     pub ignore_init_module_imports: Option<bool>,
+    #[option(
+        doc = "The line length to use when enforcing long-lines violations (like E501).",
+        default = "88",
+        value_type = "usize",
+        example = r#"
+            # Allow lines to be as long as 120 characters.
+            line-length = 120
+        "#
+    )]
     pub line_length: Option<usize>,
+    #[option(
+        doc = r#"
+            A list of check code prefixes to enable. Prefixes can specify exact checks (like
+            `F841`), entire categories (like `F`), or anything in between.
+
+            When breaking ties between enabled and disabled checks (via `select` and `ignore`,
+            respectively), more specific prefixes override less specific prefixes.
+        "#,
+        default = r#"["E", "F"]"#,
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # On top of the defaults (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
+            select = ["E", "F", "B", "Q"]
+        "#
+    )]
     pub select: Option<Vec<CheckCodePrefix>>,
+    #[option(
+        doc = r#"
+            Whether to show source code snippets when reporting lint error violations (overridden by
+            the `--show-source` command-line flag).
+        "#,
+        default = "false",
+        value_type = "bool",
+        example = r#"
+            # By default, always show source code snippets.
+            show-source = true
+        "#
+    )]
     pub show_source: Option<bool>,
+    #[option(
+        doc = "The source code paths to consider, e.g., when resolving first- vs. third-party \
+               imports.",
+        default = r#"["."]"#,
+        value_type = "Vec<PathBuf>",
+        example = r#"
+            # Allow imports relative to the "src" and "test" directories.
+            src = ["src", "test"]
+        "#
+    )]
     pub src: Option<Vec<String>>,
+    #[option(
+        doc = r#"
+            The Python version to target, e.g., when considering automatic code upgrades, like
+            rewriting type annotations. Note that the target version will _not_ be inferred from the
+            _current_ Python version, and instead must be specified explicitly (as seen below).
+        "#,
+        default = r#""py310""#,
+        value_type = "PythonVersion",
+        example = r#"
+            # Always generate Python 3.7-compatible code.
+            target-version = "py37"
+        "#
+    )]
     pub target_version: Option<PythonVersion>,
+    #[option(
+        doc = "A list of check code prefixes to consider un-autofix-able.",
+        default = "[]",
+        value_type = "Vec<CheckCodePrefix>",
+        example = r#"
+            # Disable autofix for unused imports (`F401`).
+            unfixable = ["F401"]
+        "#
+    )]
     pub unfixable: Option<Vec<CheckCodePrefix>>,
     // Plugins
+    #[option_group]
     pub flake8_annotations: Option<flake8_annotations::settings::Options>,
+    #[option_group]
     pub flake8_bugbear: Option<flake8_bugbear::settings::Options>,
+    #[option_group]
     pub flake8_quotes: Option<flake8_quotes::settings::Options>,
+    #[option_group]
     pub flake8_tidy_imports: Option<flake8_tidy_imports::settings::Options>,
+    #[option_group]
+    pub flake8_import_conventions: Option<flake8_import_conventions::settings::Options>,
+    #[option_group]
     pub isort: Option<isort::settings::Options>,
+    #[option_group]
     pub mccabe: Option<mccabe::settings::Options>,
+    #[option_group]
     pub pep8_naming: Option<pep8_naming::settings::Options>,
+    #[option_group]
     pub pyupgrade: Option<pyupgrade::settings::Options>,
     // Tables are required to go last.
+    #[option(
+        doc = r#"
+            A list of mappings from file pattern to check code prefixes to exclude, when considering
+            any matching files.
+        "#,
+        default = "{}",
+        value_type = "HashMap<String, Vec<CheckCodePrefix>>",
+        example = r#"
+            # Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
+            [tool.ruff.per-file-ignores]
+            "__init__.py" = ["E402"]
+            "path/to/file.py" = ["E402"]
+        "#
+    )]
     pub per_file_ignores: Option<FxHashMap<String, Vec<CheckCodePrefix>>>,
 }

src/settings/options_base.rs

@@ -0,0 +1,24 @@
+#[derive(Debug)]
+pub struct OptionGroup {
+    pub name: &'static str,
+    pub fields: Vec<OptionEntry>,
+}
+
+#[derive(Debug)]
+pub struct OptionField {
+    pub name: &'static str,
+    pub doc: &'static str,
+    pub default: &'static str,
+    pub value_type: &'static str,
+    pub example: &'static str,
+}
+
+#[derive(Debug)]
+pub enum OptionEntry {
+    Field(OptionField),
+    Group(OptionGroup),
+}
+
+pub trait ConfigurationOptions {
+    fn get_available_options() -> Vec<OptionEntry>;
+}

src/settings/pyproject.rs

@@ -96,6 +96,7 @@ pub fn load_options(pyproject: Option<&PathBuf>) -> Result<Options> {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::BTreeMap;
     use std::env::current_dir;
     use std::path::PathBuf;
     use std::str::FromStr;
@@ -110,7 +111,10 @@ mod tests {
         find_project_root, find_pyproject_toml, parse_pyproject_toml, Options, Pyproject, Tools,
     };
     use crate::settings::types::PatternPrefixPair;
-    use crate::{flake8_bugbear, flake8_quotes, flake8_tidy_imports, mccabe, pep8_naming};
+    use crate::{
+        flake8_bugbear, flake8_import_conventions, flake8_quotes, flake8_tidy_imports, mccabe,
+        pep8_naming,
+    };
 
     #[test]
     fn deserialize() -> Result<()> {
@@ -157,6 +161,7 @@ mod tests {
                     flake8_bugbear: None,
                     flake8_quotes: None,
                     flake8_tidy_imports: None,
+                    flake8_import_conventions: None,
                     isort: None,
                     mccabe: None,
                     pep8_naming: None,
@@ -199,6 +204,7 @@ line-length = 79
                     flake8_bugbear: None,
                     flake8_quotes: None,
                     flake8_tidy_imports: None,
+                    flake8_import_conventions: None,
                     isort: None,
                     mccabe: None,
                     pep8_naming: None,
@@ -241,6 +247,7 @@ exclude = ["foo.py"]
                     flake8_bugbear: None,
                     flake8_quotes: None,
                     flake8_tidy_imports: None,
+                    flake8_import_conventions: None,
                     isort: None,
                     mccabe: None,
                     pep8_naming: None,
@@ -283,6 +290,7 @@ select = ["E501"]
                     flake8_bugbear: None,
                     flake8_quotes: None,
                     flake8_tidy_imports: None,
+                    flake8_import_conventions: None,
                     isort: None,
                     mccabe: None,
                     pep8_naming: None,
@@ -326,6 +334,7 @@ ignore = ["E501"]
                     flake8_bugbear: None,
                     flake8_quotes: None,
                     flake8_tidy_imports: None,
+                    flake8_import_conventions: None,
                     isort: None,
                     mccabe: None,
                     pep8_naming: None,
@@ -422,6 +431,13 @@ other-attribute = 1
                 flake8_tidy_imports: Some(flake8_tidy_imports::settings::Options {
                     ban_relative_imports: Some(Strictness::Parents)
                 }),
+                flake8_import_conventions: Some(flake8_import_conventions::settings::Options {
+                    aliases: Some(BTreeMap::from([("pandas".to_string(), "pd".to_string(),)])),
+                    extend_aliases: Some(BTreeMap::from([(
+                        "dask.dataframe".to_string(),
+                        "dd".to_string(),
+                    )])),
+                }),
                 isort: None,
                 mccabe: Some(mccabe::settings::Options {
                     max_complexity: Some(10),