Bump version to 0.0.187

Add ruff-lsp to README

.github/workflows/ci.yaml

@@ -39,7 +39,7 @@ jobs:
       - run: ./target/release/ruff_dev generate-rules-table
       - run: ./target/release/ruff_dev generate-options
       - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. You may have to rerun 'cargo dev generate-options' and/or 'cargo dev generate-rules-table'."
-      - run: ./target/release/ruff_dev generate-check-code-prefix && cargo fmt -- src/checks_gen.rs
+      - run: ./target/release/ruff_dev generate-check-code-prefix
       - run: git diff --quiet src/checks_gen.rs || echo "::error file=src/checks_gen.rs::This file is outdated. You may have to rerun 'cargo dev generate-check-code-prefix'."
       - run: git diff --exit-code -- README.md src/checks_gen.rs
 

.pre-commit-config.yaml

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

Cargo.lock

@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.184-dev.0"
+version = "0.0.187-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1845,7 +1845,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.184"
+version = "0.0.187"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1901,7 +1901,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.184"
+version = "0.0.187"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1919,7 +1919,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.184"
+version = "0.0.187"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1962,7 +1962,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -1972,7 +1972,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -1995,7 +1995,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2012,7 +2012,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "ahash",
  "anyhow",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.184"
+version = "0.0.187"
 edition = "2021"
 rust-version = "1.65.0"
 
@@ -43,11 +43,11 @@ 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.184", path = "ruff_macros" }
+ruff_macros = { version = "0.0.187", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = { version = "1.0.87" }
 strum = { version = "0.24.1", features = ["strum_macros"] }

README.md

@@ -118,6 +118,8 @@ Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 pip install ruff
 ```
 
+[![Packaging status](https://repology.org/badge/vertical-allrepos/ruff-python-linter.svg?exclude_unsupported=1)](https://repology.org/project/ruff-python-linter/versions)
+
 For **macOS Homebrew** and **Linuxbrew** users, Ruff is also available as [`ruff`](https://formulae.brew.sh/formula/ruff) on Homebrew:
 
 ```shell
@@ -157,7 +159,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.184
+    rev: v0.0.187
     hooks:
       - id: ruff
 ```
@@ -354,7 +356,7 @@ There are a few exceptions to these rules:
    a default configuration. If a user-specific configuration file exists
    at `${config_dir}/ruff/pyproject.toml`,
    that file will be used instead of the default configuration, with `${config_dir}` being
-   determined via the [`dirs](https://docs.rs/dirs/4.0.0/dirs/fn.config_dir.html) crate, and all
+   determined via the [`dirs`](https://docs.rs/dirs/4.0.0/dirs/fn.config_dir.html) crate, and all
    relative paths being again resolved relative to the _current working directory_.
 4. Any `pyproject.toml`-supported settings that are provided on the command-line (e.g., via
    `--select`) will override the settings in _every_ resolved configuration file.
@@ -881,9 +883,9 @@ For more, see [pandas-vet](https://pypi.org/project/pandas-vet/0.2.3/) on PyPI.
 | PDV002 | UseOfInplaceArgument | `inplace=True` should be avoided; it has inconsistent behavior |  |
 | PDV003 | UseOfDotIsNull | `.isna` is preferred to `.isnull`; functionality is equivalent |  |
 | PDV004 | UseOfDotNotNull | `.notna` is preferred to `.notnull`; functionality is equivalent |  |
-| PDV007 | UseOfDotIx | ``ix` i` deprecated; use more explicit `.loc` o` `.iloc` |  |
+| PDV007 | UseOfDotIx | `.ix` is deprecated; use more explicit `.loc` or `.iloc` |  |
 | PDV008 | UseOfDotAt | Use `.loc` instead of `.at`.  If speed is important, use numpy. |  |
-| PDV009 | UseOfDotIat | Use `.iloc` instea` of `.iat`.  If speed is important, use numpy. |  |
+| PDV009 | UseOfDotIat | Use `.iloc` instead of `.iat`.  If speed is important, use numpy. |  |
 | PDV010 | UseOfDotPivotOrUnstack | `.pivot_table` is preferred to `.pivot` or `.unstack`; provides same functionality |  |
 | PDV011 | UseOfDotValues | Use `.to_numpy()` instead of `.values` |  |
 | PDV012 | UseOfDotReadTable | `.read_csv` is preferred to `.read_table`; provides same functionality |  |
@@ -898,6 +900,8 @@ For more, see [pygrep-hooks](https://github.com/pre-commit/pygrep-hooks) on GitH
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
 | PGH001 | NoEval | No builtin `eval()` allowed |  |
+| PGH002 | DeprecatedLogWarn | `warn` is deprecated in favor of `warning` |  |
+| PGH003 | BlanketTypeIgnore | Use specific error codes when ignoring type issues |  |
 
 ### Pylint (PLC, PLE, PLR, PLW)
 
@@ -933,21 +937,100 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 
 ### VS Code (Official)
 
-Download the [Ruff VS Code extension](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff).
+Download the [Ruff VS Code extension](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff),
+which supports autofix actions, import sorting, and more.
 
-### Language Server Protocol
+![](https://user-images.githubusercontent.com/1309177/205175763-cf34871d-5c05-4abf-9916-440afc82dbf8.gif)
 
-Ruff is available as a [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/)
-server, distributed as the [`python-lsp-ruff`](https://github.com/python-lsp/python-lsp-ruff) plugin
-for [`python-lsp-server`](https://github.com/python-lsp/python-lsp-server), both of which are
-installable via [PyPI](https://pypi.org/project/python-lsp-ruff/):
+### Language Server Protocol (Official)
+
+Ruff supports the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)
+via the [`ruff-lsp`](https://github.com/charliermarsh/ruff-lsp) Python package, available on
+[PyPI](https://pypi.org/project/ruff-lsp/).
+
+[`ruff-lsp`](https://github.com/charliermarsh/ruff-lsp) enables Ruff to be used with any editor that
+supports the Language Server Protocol, including [Neovim](https://github.com/charliermarsh/ruff-lsp#example-neovim),
+[Sublime Text](https://github.com/charliermarsh/ruff-lsp#example-sublime-text), Emacs, and more.
+
+For example, to use `ruff-lsp` with Neovim, install `ruff-lsp` from PyPI along with
+[`nvim-lspconfig`](https://github.com/neovim/nvim-lspconfig). Then, add something like the following
+to your `init.lua`:
+
+```lua
+-- See: https://github.com/neovim/nvim-lspconfig/tree/54eb2a070a4f389b1be0f98070f81d23e2b1a715#suggested-configuration
+local opts = { noremap=true, silent=true }
+vim.keymap.set('n', '<space>e', vim.diagnostic.open_float, opts)
+vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, opts)
+vim.keymap.set('n', ']d', vim.diagnostic.goto_next, opts)
+vim.keymap.set('n', '<space>q', vim.diagnostic.setloclist, opts)
+
+-- Use an on_attach function to only map the following keys
+-- after the language server attaches to the current buffer
+local on_attach = function(client, bufnr)
+  -- Enable completion triggered by <c-x><c-o>
+  vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
+
+  -- Mappings.
+  -- See `:help vim.lsp.*` for documentation on any of the below functions
+  local bufopts = { noremap=true, silent=true, buffer=bufnr }
+  vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, bufopts)
+  vim.keymap.set('n', 'gd', vim.lsp.buf.definition, bufopts)
+  vim.keymap.set('n', 'K', vim.lsp.buf.hover, bufopts)
+  vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, bufopts)
+  vim.keymap.set('n', '<C-k>', vim.lsp.buf.signature_help, bufopts)
+  vim.keymap.set('n', '<space>wa', vim.lsp.buf.add_workspace_folder, bufopts)
+  vim.keymap.set('n', '<space>wr', vim.lsp.buf.remove_workspace_folder, bufopts)
+  vim.keymap.set('n', '<space>wl', function()
+    print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
+  end, bufopts)
+  vim.keymap.set('n', '<space>D', vim.lsp.buf.type_definition, bufopts)
+  vim.keymap.set('n', '<space>rn', vim.lsp.buf.rename, bufopts)
+  vim.keymap.set('n', '<space>ca', vim.lsp.buf.code_action, bufopts)
+  vim.keymap.set('n', 'gr', vim.lsp.buf.references, bufopts)
+  vim.keymap.set('n', '<space>f', function() vim.lsp.buf.format { async = true } end, bufopts)
+end
+
+-- Configure `ruff-lsp`.
+local configs = require 'lspconfig.configs'
+if not configs.ruff_lsp then
+  configs.ruff_lsp = {
+    default_config = {
+    cmd = { "ruff-lsp" },
+    filetypes = {'python'},
+    root_dir = require('lspconfig').util.find_git_ancestor,
+    settings = {
+      ruff_lsp = {
+        -- Any extra CLI arguments for `ruff` go here.
+        args = {}
+      }
+    }
+  }
+}
+end
+
+require('lspconfig').ruff_lsp.setup {
+  on_attach = on_attach,
+}
+```
+
+Upon successful installation, you should see Ruff's diagnostics surfaced directly in your editor:
+
+![Code Actions available in Neovim](https://user-images.githubusercontent.com/1309177/208278707-25fa37e4-079d-4597-ad35-b95dba066960.png)
+
+### Language Server Protocol (Unofficial)
+
+Ruff is also available as the [`python-lsp-ruff`](https://github.com/python-lsp/python-lsp-ruff)
+plugin for [`python-lsp-server`](https://github.com/python-lsp/python-lsp-ruff), both of which are
+installable from PyPI:
 
 ```shell
 pip install python-lsp-server python-lsp-ruff
 ```
 
-The LSP server can be used with any editor that supports the Language Server Protocol. For example,
-to use it with Neovim, you would add something like the following to your `init.lua`:
+The LSP server can then be used with any editor that supports the Language Server Protocol.
+
+For example, to use `python-lsp-ruff` with Neovim, add something like the following to your
+`init.lua`:
 
 ```lua
 require'lspconfig'.pylsp.setup {
@@ -956,6 +1039,15 @@ require'lspconfig'.pylsp.setup {
       plugins = {
         ruff = {
           enabled = true
+        },
+        pycodestyle = {
+          enabled = false
+        },
+        pyflakes = {
+          enabled = false
+        },
+        mccabe = {
+          enabled = false
         }
       }
     }
@@ -963,9 +1055,6 @@ require'lspconfig'.pylsp.setup {
 }
 ```
 
-[`ruffd`](https://github.com/Seamooo/ruffd) is another implementation of the Language Server
-Protocol (LSP) for Ruff, written in Rust.
-
 ### PyCharm
 
 Ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
@@ -980,8 +1069,8 @@ Ruff should then appear as a runnable action:
 
 ### Vim & Neovim
 
-Ruff can be integrated into any editor that supports the Language Server Protocol (LSP) (see:
-[Language Server Protocol](#language-server-protocol)).
+Ruff can be integrated into any editor that supports the Language Server Protocol via [`ruff-lsp`](https://github.com/charliermarsh/ruff-lsp)
+(see: [Language Server Protocol](#language-server-protocol-official)).
 
 Ruff is also available as part of the [coc-pyright](https://github.com/fannheyward/coc-pyright)
 extension for `coc.nvim`.
@@ -1111,7 +1200,7 @@ natively, including:
 - [`mccabe`](https://pypi.org/project/mccabe/)
 - [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`pydocstyle`](https://pypi.org/project/pydocstyle/)
-- [`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (1/10)
+- [`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (3/10)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (16/33)
 - [`yesqa`](https://github.com/asottile/yesqa)
 
@@ -1167,7 +1256,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 
 Ruff can also replace [`isort`](https://pypi.org/project/isort/),
 [`yesqa`](https://github.com/asottile/yesqa), [`eradicate`](https://pypi.org/project/eradicate/),
-[`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (1/10), and a subset of the rules
+[`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (3/10), and a subset of the rules
 implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (16/33).
 
 If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
@@ -1488,7 +1577,7 @@ ignored when evaluating (e.g.) unused-variable checks. The default expression ma
 ```toml
 [tool.ruff]
 # Only ignore variables named "_".
-dummy_variable_rgx = "^_$"
+dummy-variable-rgx = "^_$"
 ```
 
 ---

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.184"
+version = "0.0.187"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.184"
+version = "0.0.187"
 dependencies = [
  "anyhow",
  "bincode",
@@ -2028,7 +2028,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2038,7 +2038,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2061,7 +2061,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2078,7 +2078,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=8d879a53197f9c73062f6160410bdba796a71cbf#8d879a53197f9c73062f6160410bdba796a71cbf"
+source = "git+https://github.com/RustPython/RustPython.git?rev=c01f014b1269eedcf4bdb45d5fbc62ae2beecf31#c01f014b1269eedcf4bdb45d5fbc62ae2beecf31"
 dependencies = [
  "ahash",
  "anyhow",

flake8_to_ruff/Cargo.toml

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

resources/test/fixtures/pycodestyle/E501.py

@@ -55,3 +55,8 @@ sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labor
 
 # OK
 # https://loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong.url.com
+
+# Not OK
+_ = """
+Source: https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+"""

resources/test/fixtures/pygrep-hooks/PGH002_0.py

@@ -0,0 +1,8 @@
+import logging
+import warnings
+from warnings import warn
+
+warnings.warn("this is ok")
+warn("by itself is also ok")
+logging.warning("this is fine")
+log.warning("this is ok")

resources/test/fixtures/pygrep-hooks/PGH002_1.py

@@ -0,0 +1,15 @@
+import logging
+from logging import warn
+
+logging.warn("this is not ok")
+log.warn("this is also not ok")
+warn("not ok")
+
+
+def foo():
+    from logging import warn
+
+    def warn():
+        pass
+
+    warn("has been redefined, but we will still report it")

resources/test/fixtures/pygrep-hooks/PGH003_0.py

@@ -0,0 +1,11 @@
+x = 1  # type: ignore
+x = 1  # type ignore
+x = 1  # type:ignore
+
+x = 1
+x = 1  # type ignore  # noqa
+x = 1  # type: ignore[attr-defined]
+x = 1  # type: ignore[attr-defined, name-defined]
+x = 1  # type: ignore[type-mismatch]  # noqa
+x = 1  # type: Union[int, str]
+x = 1  # type: ignoreme

resources/test/fixtures/ruff/RUF100.py

@@ -69,3 +69,13 @@ _ = """Lorem ipsum dolor sit amet.
 
 Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.
 """  # noqa
+
+# Valid
+# this is a veryyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy long comment  # noqa: E501
+
+# Valid
+_ = """Here's a source: https://github.com/ethereum/web3.py/blob/ffe59daf10edc19ee5f05227b25bac8d090e8aa4/web3/_utils/events.py#L201
+
+May raise:
+- DeserializationError if the abi string is invalid or abi or log topics/data do not match
+"""  # noqa: E501

resources/test/package/pyproject.toml

@@ -0,0 +1,2 @@
+[tool.ruff]
+src = ["."]

resources/test/package/src/package/app.py

@@ -0,0 +1,4 @@
+from package.core import method
+
+if __name__ == "__main__":
+    method()

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.184"
+version = "0.0.187"
 edition = "2021"
 
 [dependencies]
@@ -11,8 +11,8 @@ itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
 once_cell = { version = "1.16.0" }
 ruff = { path = ".." }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "8d879a53197f9c73062f6160410bdba796a71cbf" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "c01f014b1269eedcf4bdb45d5fbc62ae2beecf31" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }

ruff_dev/src/generate_check_code_prefix.rs

@@ -1,18 +1,18 @@
 //! Generate the `CheckCodePrefix` enum.
 
 use std::collections::{BTreeMap, BTreeSet};
-use std::fs::OpenOptions;
+use std::fs;
 use std::io::Write;
+use std::path::PathBuf;
+use std::process::{Command, Output, Stdio};
 
-use anyhow::Result;
+use anyhow::{ensure, Result};
 use clap::Parser;
 use codegen::{Scope, Type, Variant};
 use itertools::Itertools;
 use ruff::checks::{CheckCode, CODE_REDIRECTS, PREFIX_REDIRECTS};
 use strum::IntoEnumIterator;
 
-const FILE: &str = "src/checks_gen.rs";
-
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
 pub struct Cli {
@@ -107,7 +107,7 @@ pub fn main(cli: &Cli) -> Result<()> {
     for (prefix, codes) in &prefix_to_codes {
         if let Some(target) = CODE_REDIRECTS.get(&prefix.as_str()) {
             gen = gen.line(format!(
-                "CheckCodePrefix::{prefix} => {{ eprintln!(\"{{}}{{}} {{}}\", \
+                "CheckCodePrefix::{prefix} => {{ one_time_warning!(\"{{}}{{}} {{}}\", \
                  \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been remapped to \
                  `{}`\".bold()); \n vec![{}] }}",
                 prefix,
@@ -119,7 +119,7 @@ pub fn main(cli: &Cli) -> Result<()> {
             ));
         } else if let Some(target) = PREFIX_REDIRECTS.get(&prefix.as_str()) {
             gen = gen.line(format!(
-                "CheckCodePrefix::{prefix} => {{ eprintln!(\"{{}}{{}} {{}}\", \
+                "CheckCodePrefix::{prefix} => {{ one_time_warning!(\"{{}}{{}} {{}}\", \
                  \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been remapped to \
                  `{}`\".bold()); \n vec![{}] }}",
                 prefix,
@@ -182,6 +182,8 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push_str("use crate::checks::CheckCode;");
     output.push('\n');
+    output.push_str("use crate::one_time_warning;");
+    output.push('\n');
     output.push('\n');
     output.push_str(&scope.to_string());
     output.push('\n');
@@ -202,12 +204,25 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push('\n');
 
+    let rustfmt = Command::new("rustfmt")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+    write!(rustfmt.stdin.as_ref().unwrap(), "{output}")?;
+    let Output { status, stdout, .. } = rustfmt.wait_with_output()?;
+    ensure!(status.success(), "rustfmt failed with {status}");
+
     // Write the output to `src/checks_gen.rs` (or stdout).
     if cli.dry_run {
-        println!("{output}");
+        println!("{}", String::from_utf8(stdout)?);
     } else {
-        let mut f = OpenOptions::new().write(true).truncate(true).open(FILE)?;
-        write!(f, "{output}")?;
+        let file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .expect("Failed to find root directory")
+            .join("src/checks_gen.rs");
+        if fs::read(&file).map_or(true, |old| old != stdout) {
+            fs::write(&file, stdout)?;
+        }
     }
 
     Ok(())

ruff_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.184"
+version = "0.0.187"
 edition = "2021"
 
 [lib]

src/ast/whitespace.rs

@@ -4,7 +4,7 @@ use std::str::Lines;
 use rustpython_ast::{Located, Location};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 
 /// Extract the leading indentation from a line.
 pub fn indentation<'a, T>(checker: &'a Checker, located: &'a Located<T>) -> Cow<'a, str> {

src/autofix/fixer.rs

@@ -10,7 +10,7 @@ use crate::autofix::Fix;
 use crate::checks::Check;
 use crate::source_code_locator::SourceCodeLocator;
 
-#[derive(Debug, Hash)]
+#[derive(Debug, Copy, Clone, Hash)]
 pub enum Mode {
     Generate,
     Apply,

src/cache.rs

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::autofix::fixer;
 use crate::message::Message;
-use crate::settings::Settings;
+use crate::settings::{flags, Settings};
 
 const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -34,43 +34,6 @@ struct CheckResult {
     messages: Vec<Message>,
 }
 
-pub enum Mode {
-    ReadWrite,
-    ReadOnly,
-    WriteOnly,
-    None,
-}
-
-impl Mode {
-    fn allow_read(&self) -> bool {
-        match self {
-            Mode::ReadWrite => true,
-            Mode::ReadOnly => true,
-            Mode::WriteOnly => false,
-            Mode::None => false,
-        }
-    }
-
-    fn allow_write(&self) -> bool {
-        match self {
-            Mode::ReadWrite => true,
-            Mode::ReadOnly => false,
-            Mode::WriteOnly => true,
-            Mode::None => false,
-        }
-    }
-}
-
-impl From<bool> for Mode {
-    fn from(value: bool) -> Self {
-        if value {
-            Mode::ReadWrite
-        } else {
-            Mode::None
-        }
-    }
-}
-
 fn cache_dir() -> &'static str {
     "./.ruff_cache"
 }
@@ -79,10 +42,10 @@ fn content_dir() -> &'static str {
     "content"
 }
 
-fn cache_key(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> u64 {
+fn cache_key<P: AsRef<Path>>(path: P, settings: &Settings, autofix: fixer::Mode) -> u64 {
     let mut hasher = DefaultHasher::new();
     CARGO_PKG_VERSION.hash(&mut hasher);
-    path.absolutize().unwrap().hash(&mut hasher);
+    path.as_ref().absolutize().unwrap().hash(&mut hasher);
     settings.hash(&mut hasher);
     autofix.hash(&mut hasher);
     hasher.finish()
@@ -128,14 +91,14 @@ fn read_sync(key: u64) -> Result<Vec<u8>, std::io::Error> {
 }
 
 /// Get a value from the cache.
-pub fn get(
-    path: &Path,
+pub fn get<P: AsRef<Path>>(
+    path: P,
     metadata: &Metadata,
     settings: &Settings,
-    autofix: &fixer::Mode,
-    mode: &Mode,
+    autofix: fixer::Mode,
+    cache: flags::Cache,
 ) -> Option<Vec<Message>> {
-    if !mode.allow_read() {
+    if matches!(cache, flags::Cache::Disabled) {
         return None;
     };
 
@@ -157,15 +120,15 @@ pub fn get(
 }
 
 /// Set a value in the cache.
-pub fn set(
-    path: &Path,
+pub fn set<P: AsRef<Path>>(
+    path: P,
     metadata: &Metadata,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: fixer::Mode,
     messages: &[Message],
-    mode: &Mode,
+    cache: flags::Cache,
 ) {
-    if !mode.allow_write() {
+    if matches!(cache, flags::Cache::Disabled) {
         return;
     };
 

src/check_lines.rs

@@ -1,294 +0,0 @@
-//! Lint rules based on checking raw physical lines.
-
-use nohash_hasher::IntMap;
-use once_cell::sync::Lazy;
-use regex::Regex;
-use rustpython_parser::ast::Location;
-
-use crate::ast::types::Range;
-use crate::autofix::Fix;
-use crate::checks::{Check, CheckCode, CheckKind, CODE_REDIRECTS};
-use crate::noqa;
-use crate::noqa::{is_file_exempt, Directive};
-use crate::settings::{flags, Settings};
-
-// Regex from PEP263.
-static CODING_COMMENT_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").unwrap());
-
-static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").unwrap());
-
-/// Whether the given line is too long and should be reported.
-fn should_enforce_line_length(line: &str, length: usize, limit: usize) -> bool {
-    if length <= limit {
-        return false;
-    }
-    let mut chunks = line.split_whitespace();
-    let (Some(first), Some(_)) = (chunks.next(), chunks.next()) else {
-        // Single word / no printable chars - no way to make the line shorter
-        return false;
-    };
-
-    // Do not enforce the line length for commented lines that end with a URL
-    // or contain only a single word.
-    !(first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)))
-}
-
-pub fn check_lines(
-    checks: &mut Vec<Check>,
-    contents: &str,
-    noqa_line_for: &IntMap<usize, usize>,
-    settings: &Settings,
-    autofix: flags::Autofix,
-    noqa: flags::Noqa,
-) {
-    let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::UP009);
-    let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
-    let enforce_noqa = settings.enabled.contains(&CheckCode::RUF100);
-
-    let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
-    let mut line_checks = vec![];
-    let mut ignored = vec![];
-
-    checks.sort_by_key(|check| check.location);
-    let mut checks_iter = checks.iter().enumerate().peekable();
-    if let Some((_index, check)) = checks_iter.peek() {
-        assert!(check.location.row() >= 1);
-    }
-
-    macro_rules! add_if {
-        ($check:expr, $noqa_lineno:expr, $line:expr) => {{
-            match noqa_directives
-                .entry($noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive($line), vec![]))
-            {
-                (Directive::All(..), matches) => {
-                    matches.push($check.kind.code().as_ref());
-                    if matches!(noqa, flags::Noqa::Disabled) {
-                        line_checks.push($check);
-                    }
-                }
-                (Directive::Codes(.., codes), matches) => {
-                    if noqa::includes($check.kind.code(), codes) {
-                        matches.push($check.kind.code().as_ref());
-                        if matches!(noqa, flags::Noqa::Disabled) {
-                            line_checks.push($check);
-                        }
-                    } else {
-                        line_checks.push($check);
-                    }
-                }
-                (Directive::None, ..) => line_checks.push($check),
-            }
-        }};
-    }
-
-    let lines: Vec<&str> = contents.lines().collect();
-    for (lineno, line) in lines.iter().enumerate() {
-        // If we hit an exemption for the entire file, bail.
-        if is_file_exempt(line) {
-            checks.drain(..);
-            return;
-        }
-
-        // Grab the noqa (logical) line number for the current (physical) line.
-        // If there are newlines at the end of the file, they won't be represented in
-        // `noqa_line_for`, so fallback to the current line.
-        let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-
-        // Enforce unnecessary coding comments (UP009).
-        if enforce_unnecessary_coding_comment {
-            if lineno < 2 {
-                // PEP3120 makes utf-8 the default encoding.
-                if CODING_COMMENT_REGEX.is_match(line) {
-                    let mut check = Check::new(
-                        CheckKind::PEP3120UnnecessaryCodingComment,
-                        Range {
-                            location: Location::new(lineno + 1, 0),
-                            end_location: Location::new(lineno + 2, 0),
-                        },
-                    );
-                    if matches!(autofix, flags::Autofix::Enabled)
-                        && settings.fixable.contains(check.kind.code())
-                    {
-                        check.amend(Fix::deletion(
-                            Location::new(lineno + 1, 0),
-                            Location::new(lineno + 2, 0),
-                        ));
-                    }
-                    add_if!(check, noqa_lineno, lines[noqa_lineno]);
-                }
-            }
-        }
-
-        if enforce_noqa {
-            noqa_directives
-                .entry(noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-        }
-
-        // Remove any ignored checks.
-        while let Some((index, check)) =
-            checks_iter.next_if(|(_index, check)| check.location.row() == lineno + 1)
-        {
-            let noqa = noqa_directives
-                .entry(noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-
-            match noqa {
-                (Directive::All(..), matches) => {
-                    matches.push(check.kind.code().as_ref());
-                    ignored.push(index);
-                }
-                (Directive::Codes(.., codes), matches) => {
-                    if noqa::includes(check.kind.code(), codes) {
-                        matches.push(check.kind.code().as_ref());
-                        ignored.push(index);
-                    }
-                }
-                (Directive::None, ..) => {}
-            }
-        }
-
-        // Enforce line length violations (E501).
-        if enforce_line_too_long {
-            let line_length = line.chars().count();
-            if should_enforce_line_length(line, line_length, settings.line_length) {
-                let check = Check::new(
-                    CheckKind::LineTooLong(line_length, settings.line_length),
-                    Range {
-                        location: Location::new(lineno + 1, settings.line_length),
-                        end_location: Location::new(lineno + 1, line_length),
-                    },
-                );
-                add_if!(check, noqa_lineno, lines[noqa_lineno]);
-            }
-        }
-    }
-
-    // Enforce newlines at end of files (W292).
-    if settings.enabled.contains(&CheckCode::W292) && !contents.ends_with('\n') {
-        // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't
-        // want to raise W292 anyway).
-        if let Some(line) = lines.last() {
-            let check = Check::new(
-                CheckKind::NoNewLineAtEndOfFile,
-                Range {
-                    location: Location::new(lines.len(), line.len() + 1),
-                    end_location: Location::new(lines.len(), line.len() + 1),
-                },
-            );
-
-            let lineno = lines.len() - 1;
-            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-            add_if!(check, noqa_lineno, lines[noqa_lineno]);
-        }
-    }
-
-    // Enforce that the noqa directive was actually used (RUF100).
-    if enforce_noqa {
-        for (row, (directive, matches)) in noqa_directives {
-            match directive {
-                Directive::All(spaces, start, end) => {
-                    if matches.is_empty() {
-                        let mut check = Check::new(
-                            CheckKind::UnusedNOQA(None),
-                            Range {
-                                location: Location::new(row + 1, start),
-                                end_location: Location::new(row + 1, end),
-                            },
-                        );
-                        if matches!(autofix, flags::Autofix::Enabled)
-                            && settings.fixable.contains(check.kind.code())
-                        {
-                            check.amend(Fix::deletion(
-                                Location::new(row + 1, start - spaces),
-                                Location::new(row + 1, lines[row].chars().count()),
-                            ));
-                        }
-                        line_checks.push(check);
-                    }
-                }
-                Directive::Codes(spaces, start, end, codes) => {
-                    let mut invalid_codes = vec![];
-                    let mut valid_codes = vec![];
-                    for code in codes {
-                        let code = CODE_REDIRECTS.get(code).map_or(code, AsRef::as_ref);
-                        if matches.contains(&code) || settings.external.contains(code) {
-                            valid_codes.push(code.to_string());
-                        } else {
-                            invalid_codes.push(code.to_string());
-                        }
-                    }
-
-                    if !invalid_codes.is_empty() {
-                        let mut check = Check::new(
-                            CheckKind::UnusedNOQA(Some(invalid_codes)),
-                            Range {
-                                location: Location::new(row + 1, start),
-                                end_location: Location::new(row + 1, end),
-                            },
-                        );
-                        if matches!(autofix, flags::Autofix::Enabled)
-                            && settings.fixable.contains(check.kind.code())
-                        {
-                            if valid_codes.is_empty() {
-                                check.amend(Fix::deletion(
-                                    Location::new(row + 1, start - spaces),
-                                    Location::new(row + 1, lines[row].chars().count()),
-                                ));
-                            } else {
-                                check.amend(Fix::replacement(
-                                    format!("# noqa: {}", valid_codes.join(", ")),
-                                    Location::new(row + 1, start),
-                                    Location::new(row + 1, lines[row].chars().count()),
-                                ));
-                            }
-                        }
-                        line_checks.push(check);
-                    }
-                }
-                Directive::None => {}
-            }
-        }
-    }
-
-    if matches!(noqa, flags::Noqa::Enabled) {
-        ignored.sort_unstable();
-        for index in ignored.iter().rev() {
-            checks.swap_remove(*index);
-        }
-    }
-    checks.extend(line_checks);
-}
-
-#[cfg(test)]
-mod tests {
-    use nohash_hasher::IntMap;
-
-    use super::check_lines;
-    use crate::checks::{Check, CheckCode};
-    use crate::settings::{flags, Settings};
-
-    #[test]
-    fn e501_non_ascii_char() {
-        let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
-        let check_with_max_line_length = |line_length: usize| {
-            let mut checks: Vec<Check> = vec![];
-            check_lines(
-                &mut checks,
-                line,
-                &IntMap::default(),
-                &Settings {
-                    line_length,
-                    ..Settings::for_rule(CheckCode::E501)
-                },
-                flags::Autofix::Enabled,
-                flags::Noqa::Enabled,
-            );
-            checks
-        };
-        assert!(!check_with_max_line_length(6).is_empty());
-        assert!(check_with_max_line_length(7).is_empty());
-    }
-}

src/checkers/ast.rs

@@ -1957,7 +1957,10 @@ where
 
                 // pygrep-hooks
                 if self.settings.enabled.contains(&CheckCode::PGH001) {
-                    pygrep_hooks::checks::no_eval(self, func);
+                    pygrep_hooks::plugins::no_eval(self, func);
+                }
+                if self.settings.enabled.contains(&CheckCode::PGH002) {
+                    pygrep_hooks::plugins::deprecated_log_warn(self, func);
                 }
 
                 // pylint

src/checkers/imports.rs

@@ -17,11 +17,14 @@ fn check_import_blocks(
     locator: &SourceCodeLocator,
     settings: &Settings,
     autofix: flags::Autofix,
+    package: Option<&Path>,
 ) -> Vec<Check> {
     let mut checks = vec![];
     for block in tracker.into_iter() {
         if !block.imports.is_empty() {
-            if let Some(check) = isort::plugins::check_imports(&block, locator, settings, autofix) {
+            if let Some(check) =
+                isort::plugins::check_imports(&block, locator, settings, autofix, package)
+            {
                 checks.push(check);
             }
         }
@@ -36,10 +39,11 @@ pub fn check_imports(
     settings: &Settings,
     autofix: flags::Autofix,
     path: &Path,
+    package: Option<&Path>,
 ) -> Vec<Check> {
     let mut tracker = ImportTracker::new(locator, directives, path);
     for stmt in python_ast {
         tracker.visit_stmt(stmt);
     }
-    check_import_blocks(tracker, locator, settings, autofix)
+    check_import_blocks(tracker, locator, settings, autofix, package)
 }

src/checkers/lines.rs

@@ -0,0 +1,90 @@
+//! Lint rules based on checking raw physical lines.
+
+use crate::checks::{Check, CheckCode};
+use crate::pycodestyle::checks::{line_too_long, no_newline_at_end_of_file};
+use crate::pygrep_hooks::plugins::blanket_type_ignore;
+use crate::pyupgrade::checks::unnecessary_coding_comment;
+use crate::settings::{flags, Settings};
+
+pub fn check_lines(
+    contents: &str,
+    commented_lines: &[usize],
+    settings: &Settings,
+    autofix: flags::Autofix,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+
+    let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::UP009);
+    let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
+    let enforce_no_newline_at_end_of_file = settings.enabled.contains(&CheckCode::W292);
+    let enforce_blanket_type_ignore = settings.enabled.contains(&CheckCode::PGH003);
+
+    let mut commented_lines_iter = commented_lines.iter().peekable();
+    for (index, line) in contents.lines().enumerate() {
+        while commented_lines_iter
+            .next_if(|lineno| &(index + 1) == *lineno)
+            .is_some()
+        {
+            if enforce_unnecessary_coding_comment {
+                if index < 2 {
+                    if let Some(check) = unnecessary_coding_comment(
+                        index,
+                        line,
+                        matches!(autofix, flags::Autofix::Enabled)
+                            && settings.fixable.contains(&CheckCode::UP009),
+                    ) {
+                        checks.push(check);
+                    }
+                }
+            }
+
+            if enforce_blanket_type_ignore {
+                if commented_lines.contains(&(index + 1)) {
+                    if let Some(check) = blanket_type_ignore(index, line) {
+                        checks.push(check);
+                    }
+                }
+            }
+        }
+
+        if enforce_line_too_long {
+            if let Some(check) = line_too_long(index, line, settings.line_length) {
+                checks.push(check);
+            }
+        }
+    }
+
+    if enforce_no_newline_at_end_of_file {
+        if let Some(check) = no_newline_at_end_of_file(contents) {
+            checks.push(check);
+        }
+    }
+
+    checks
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::check_lines;
+    use crate::checks::CheckCode;
+    use crate::settings::{flags, Settings};
+
+    #[test]
+    fn e501_non_ascii_char() {
+        let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
+        let check_with_max_line_length = |line_length: usize| {
+            check_lines(
+                line,
+                &[],
+                &Settings {
+                    line_length,
+                    ..Settings::for_rule(CheckCode::E501)
+                },
+                flags::Autofix::Enabled,
+            )
+        };
+        assert!(!check_with_max_line_length(6).is_empty());
+        assert!(check_with_max_line_length(7).is_empty());
+    }
+}

src/checkers/mod.rs

@@ -0,0 +1,5 @@
+pub mod ast;
+pub mod imports;
+pub mod lines;
+pub mod noqa;
+pub mod tokens;

src/checkers/noqa.rs

@@ -0,0 +1,148 @@
+//! `NoQA` enforcement and validation.
+
+use nohash_hasher::IntMap;
+use rustpython_parser::ast::Location;
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::checks::{Check, CheckCode, CheckKind, CODE_REDIRECTS};
+use crate::noqa;
+use crate::noqa::{is_file_exempt, Directive};
+use crate::settings::{flags, Settings};
+
+pub fn check_noqa(
+    checks: &mut Vec<Check>,
+    contents: &str,
+    commented_lines: &[usize],
+    noqa_line_for: &IntMap<usize, usize>,
+    settings: &Settings,
+    autofix: flags::Autofix,
+) {
+    let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
+    let mut ignored = vec![];
+
+    let enforce_noqa = settings.enabled.contains(&CheckCode::RUF100);
+
+    checks.sort_by_key(|check| check.location);
+    let mut checks_iter = checks.iter().enumerate().peekable();
+    if let Some((_index, check)) = checks_iter.peek() {
+        assert!(check.location.row() >= 1);
+    }
+
+    let lines: Vec<&str> = contents.lines().collect();
+    for lineno in commented_lines {
+        // If we hit an exemption for the entire file, bail.
+        if is_file_exempt(lines[lineno - 1]) {
+            checks.drain(..);
+            return;
+        }
+
+        if enforce_noqa {
+            noqa_directives
+                .entry(lineno - 1)
+                .or_insert_with(|| (noqa::extract_noqa_directive(lines[lineno - 1]), vec![]));
+        }
+
+        // Remove any ignored checks.
+        while let Some((index, check)) =
+            checks_iter.next_if(|(_index, check)| check.location.row() <= *lineno)
+        {
+            // Grab the noqa (logical) line number for the current (physical) line.
+            // If there are newlines at the end of the file, they won't be represented in
+            // `noqa_line_for`, so fallback to the current line.
+            let check_lineno = check.location.row();
+            let noqa_lineno = noqa_line_for.get(&check_lineno).unwrap_or(&check_lineno);
+            if noqa_lineno == lineno {
+                let noqa = noqa_directives.entry(noqa_lineno - 1).or_insert_with(|| {
+                    (noqa::extract_noqa_directive(lines[noqa_lineno - 1]), vec![])
+                });
+                match noqa {
+                    (Directive::All(..), matches) => {
+                        matches.push(check.kind.code().as_ref());
+                        ignored.push(index);
+                    }
+                    (Directive::Codes(.., codes), matches) => {
+                        if noqa::includes(check.kind.code(), codes) {
+                            matches.push(check.kind.code().as_ref());
+                            ignored.push(index);
+                        }
+                    }
+                    (Directive::None, ..) => {}
+                }
+            }
+        }
+    }
+
+    // Enforce that the noqa directive was actually used (RUF100).
+    if enforce_noqa {
+        for (row, (directive, matches)) in noqa_directives {
+            match directive {
+                Directive::All(spaces, start, end) => {
+                    if matches.is_empty() {
+                        let mut check = Check::new(
+                            CheckKind::UnusedNOQA(None),
+                            Range {
+                                location: Location::new(row + 1, start),
+                                end_location: Location::new(row + 1, end),
+                            },
+                        );
+                        if matches!(autofix, flags::Autofix::Enabled)
+                            && settings.fixable.contains(check.kind.code())
+                        {
+                            check.amend(Fix::deletion(
+                                Location::new(row + 1, start - spaces),
+                                Location::new(row + 1, lines[row].chars().count()),
+                            ));
+                        }
+                        checks.push(check);
+                    }
+                }
+                Directive::Codes(spaces, start, end, codes) => {
+                    let mut invalid_codes = vec![];
+                    let mut valid_codes = vec![];
+                    for code in codes {
+                        let code = CODE_REDIRECTS.get(code).map_or(code, AsRef::as_ref);
+                        if matches.contains(&code) || settings.external.contains(code) {
+                            valid_codes.push(code.to_string());
+                        } else {
+                            invalid_codes.push(code.to_string());
+                        }
+                    }
+
+                    if !invalid_codes.is_empty() {
+                        let mut check = Check::new(
+                            CheckKind::UnusedNOQA(Some(invalid_codes)),
+                            Range {
+                                location: Location::new(row + 1, start),
+                                end_location: Location::new(row + 1, end),
+                            },
+                        );
+                        if matches!(autofix, flags::Autofix::Enabled)
+                            && settings.fixable.contains(check.kind.code())
+                        {
+                            if valid_codes.is_empty() {
+                                check.amend(Fix::deletion(
+                                    Location::new(row + 1, start - spaces),
+                                    Location::new(row + 1, lines[row].chars().count()),
+                                ));
+                            } else {
+                                check.amend(Fix::replacement(
+                                    format!("# noqa: {}", valid_codes.join(", ")),
+                                    Location::new(row + 1, start),
+                                    Location::new(row + 1, lines[row].chars().count()),
+                                ));
+                            }
+                        }
+                        checks.push(check);
+                    }
+                }
+                Directive::None => {}
+            }
+        }
+    }
+
+    ignored.sort_unstable();
+    for index in ignored.iter().rev() {
+        checks.swap_remove(*index);
+    }
+}

src/checks.rs

@@ -316,6 +316,8 @@ pub enum CheckCode {
     RUF100,
     // pygrep-hooks
     PGH001,
+    PGH002,
+    PGH003,
     // pandas-vet
     PDV002,
     PDV003,
@@ -573,6 +575,7 @@ pub enum LintSource {
     Lines,
     Tokens,
     Imports,
+    NoQA,
 }
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -886,6 +889,8 @@ pub enum CheckKind {
     BooleanPositionalValueInFunctionCall,
     // pygrep-hooks
     NoEval,
+    DeprecatedLogWarn,
+    BlanketTypeIgnore,
     // flake8-unused-arguments
     UnusedFunctionArgument(String),
     UnusedMethodArgument(String),
@@ -923,7 +928,8 @@ impl CheckCode {
     /// physical lines).
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
-            CheckCode::E501 | CheckCode::W292 | CheckCode::RUF100 | CheckCode::UP009 => {
+            CheckCode::RUF100 => &LintSource::NoQA,
+            CheckCode::E501 | CheckCode::W292 | CheckCode::UP009 | CheckCode::PGH003 => {
                 &LintSource::Lines
             }
             CheckCode::ERA001
@@ -1260,6 +1266,8 @@ impl CheckCode {
             CheckCode::FBT003 => CheckKind::BooleanPositionalValueInFunctionCall,
             // pygrep-hooks
             CheckCode::PGH001 => CheckKind::NoEval,
+            CheckCode::PGH002 => CheckKind::DeprecatedLogWarn,
+            CheckCode::PGH003 => CheckKind::BlanketTypeIgnore,
             // flake8-unused-arguments
             CheckCode::ARG001 => CheckKind::UnusedFunctionArgument("...".to_string()),
             CheckCode::ARG002 => CheckKind::UnusedMethodArgument("...".to_string()),
@@ -1504,6 +1512,8 @@ impl CheckCode {
             CheckCode::PDV015 => CheckCategory::PandasVet,
             CheckCode::PDV901 => CheckCategory::PandasVet,
             CheckCode::PGH001 => CheckCategory::PygrepHooks,
+            CheckCode::PGH002 => CheckCategory::PygrepHooks,
+            CheckCode::PGH003 => CheckCategory::PygrepHooks,
             CheckCode::PLC0414 => CheckCategory::Pylint,
             CheckCode::PLC2201 => CheckCategory::Pylint,
             CheckCode::PLC3002 => CheckCategory::Pylint,
@@ -1847,6 +1857,8 @@ impl CheckKind {
             CheckKind::BooleanPositionalValueInFunctionCall => &CheckCode::FBT003,
             // pygrep-hooks
             CheckKind::NoEval => &CheckCode::PGH001,
+            CheckKind::DeprecatedLogWarn => &CheckCode::PGH002,
+            CheckKind::BlanketTypeIgnore => &CheckCode::PGH003,
             // flake8-unused-arguments
             CheckKind::UnusedFunctionArgument(..) => &CheckCode::ARG001,
             CheckKind::UnusedMethodArgument(..) => &CheckCode::ARG002,
@@ -2684,6 +2696,12 @@ impl CheckKind {
             }
             // pygrep-hooks
             CheckKind::NoEval => "No builtin `eval()` allowed".to_string(),
+            CheckKind::DeprecatedLogWarn => {
+                "`warn` is deprecated in favor of `warning`".to_string()
+            }
+            CheckKind::BlanketTypeIgnore => {
+                "Use specific error codes when ignoring type issues".to_string()
+            }
             // flake8-unused-arguments
             CheckKind::UnusedFunctionArgument(name) => {
                 format!("Unused function argument: `{name}`")
@@ -2711,13 +2729,13 @@ impl CheckKind {
                 "`.notna` is preferred to `.notnull`; functionality is equivalent".to_string()
             }
             CheckKind::UseOfDotIx => {
-                "``ix` i` deprecated; use more explicit `.loc` o` `.iloc`".to_string()
+                "`.ix` is deprecated; use more explicit `.loc` or `.iloc`".to_string()
             }
             CheckKind::UseOfDotAt => {
                 "Use `.loc` instead of `.at`.  If speed is important, use numpy.".to_string()
             }
             CheckKind::UseOfDotIat => {
-                "Use `.iloc` instea` of `.iat`.  If speed is important, use numpy.".to_string()
+                "Use `.iloc` instead of `.iat`.  If speed is important, use numpy.".to_string()
             }
             CheckKind::UseOfDotPivotOrUnstack => "`.pivot_table` is preferred to `.pivot` or \
                                                   `.unstack`; provides same functionality"

src/checks_gen.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 use strum_macros::{AsRefStr, EnumString};
 
 use crate::checks::CheckCode;
+use crate::one_time_warning;
 
 #[derive(
     EnumString, AsRefStr, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize, Deserialize,
@@ -325,6 +326,8 @@ pub enum CheckCodePrefix {
     PGH0,
     PGH00,
     PGH001,
+    PGH002,
+    PGH003,
     PLC,
     PLC0,
     PLC04,
@@ -1243,7 +1246,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::I00 => vec![CheckCode::I001],
             CheckCodePrefix::I001 => vec![CheckCode::I001],
             CheckCodePrefix::I2 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1252,7 +1255,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::TID252]
             }
             CheckCodePrefix::I25 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1261,7 +1264,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::TID252]
             }
             CheckCodePrefix::I252 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1274,7 +1277,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::ICN00 => vec![CheckCode::ICN001],
             CheckCodePrefix::ICN001 => vec![CheckCode::ICN001],
             CheckCodePrefix::M => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1283,7 +1286,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::RUF100]
             }
             CheckCodePrefix::M0 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1292,7 +1295,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::RUF100]
             }
             CheckCodePrefix::M001 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1424,10 +1427,12 @@ impl CheckCodePrefix {
             CheckCodePrefix::PDV9 => vec![CheckCode::PDV901],
             CheckCodePrefix::PDV90 => vec![CheckCode::PDV901],
             CheckCodePrefix::PDV901 => vec![CheckCode::PDV901],
-            CheckCodePrefix::PGH => vec![CheckCode::PGH001],
-            CheckCodePrefix::PGH0 => vec![CheckCode::PGH001],
-            CheckCodePrefix::PGH00 => vec![CheckCode::PGH001],
+            CheckCodePrefix::PGH => vec![CheckCode::PGH001, CheckCode::PGH002, CheckCode::PGH003],
+            CheckCodePrefix::PGH0 => vec![CheckCode::PGH001, CheckCode::PGH002, CheckCode::PGH003],
+            CheckCodePrefix::PGH00 => vec![CheckCode::PGH001, CheckCode::PGH002, CheckCode::PGH003],
             CheckCodePrefix::PGH001 => vec![CheckCode::PGH001],
+            CheckCodePrefix::PGH002 => vec![CheckCode::PGH002],
+            CheckCodePrefix::PGH003 => vec![CheckCode::PGH003],
             CheckCodePrefix::PLC => {
                 vec![CheckCode::PLC0414, CheckCode::PLC2201, CheckCode::PLC3002]
             }
@@ -1603,7 +1608,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::TID25 => vec![CheckCode::TID252],
             CheckCodePrefix::TID252 => vec![CheckCode::TID252],
             CheckCodePrefix::U => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1628,7 +1633,7 @@ impl CheckCodePrefix {
                 ]
             }
             CheckCodePrefix::U0 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1653,7 +1658,7 @@ impl CheckCodePrefix {
                 ]
             }
             CheckCodePrefix::U00 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1671,7 +1676,7 @@ impl CheckCodePrefix {
                 ]
             }
             CheckCodePrefix::U001 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1680,7 +1685,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP001]
             }
             CheckCodePrefix::U003 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1689,7 +1694,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP003]
             }
             CheckCodePrefix::U004 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1698,7 +1703,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP004]
             }
             CheckCodePrefix::U005 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1707,7 +1712,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP005]
             }
             CheckCodePrefix::U006 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1716,7 +1721,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP006]
             }
             CheckCodePrefix::U007 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1725,7 +1730,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP007]
             }
             CheckCodePrefix::U008 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1734,7 +1739,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP008]
             }
             CheckCodePrefix::U009 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1743,7 +1748,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP009]
             }
             CheckCodePrefix::U01 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1760,7 +1765,7 @@ impl CheckCodePrefix {
                 ]
             }
             CheckCodePrefix::U010 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1769,7 +1774,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP010]
             }
             CheckCodePrefix::U011 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1778,7 +1783,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP011]
             }
             CheckCodePrefix::U012 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1787,7 +1792,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP012]
             }
             CheckCodePrefix::U013 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1796,7 +1801,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP013]
             }
             CheckCodePrefix::U014 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1805,7 +1810,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP014]
             }
             CheckCodePrefix::U015 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -1814,7 +1819,7 @@ impl CheckCodePrefix {
                 vec![CheckCode::UP015]
             }
             CheckCodePrefix::U016 => {
-                eprintln!(
+                one_time_warning!(
                     "{}{} {}",
                     "warning".yellow().bold(),
                     ":".bold(),
@@ -2258,6 +2263,8 @@ impl CheckCodePrefix {
             CheckCodePrefix::PGH0 => SuffixLength::One,
             CheckCodePrefix::PGH00 => SuffixLength::Two,
             CheckCodePrefix::PGH001 => SuffixLength::Three,
+            CheckCodePrefix::PGH002 => SuffixLength::Three,
+            CheckCodePrefix::PGH003 => SuffixLength::Three,
             CheckCodePrefix::PLC => SuffixLength::Zero,
             CheckCodePrefix::PLC0 => SuffixLength::One,
             CheckCodePrefix::PLC04 => SuffixLength::Two,

src/cli.rs

@@ -120,7 +120,7 @@ pub struct Cli {
     pub autoformat: bool,
     /// The name of the file when passing it through stdin.
     #[arg(long)]
-    pub stdin_filename: Option<String>,
+    pub stdin_filename: Option<PathBuf>,
     /// Explain a rule.
     #[arg(long)]
     pub explain: Option<CheckCode>,
@@ -203,7 +203,7 @@ pub struct Arguments {
     pub show_files: bool,
     pub show_settings: bool,
     pub silent: bool,
-    pub stdin_filename: Option<String>,
+    pub stdin_filename: Option<PathBuf>,
     pub verbose: bool,
     pub watch: bool,
 }

src/commands.rs

@@ -17,9 +17,10 @@ use crate::cli::Overrides;
 use crate::iterators::par_iter;
 use crate::linter::{add_noqa_to_path, autoformat_path, lint_path, lint_stdin, Diagnostics};
 use crate::message::Message;
-use crate::resolver;
 use crate::resolver::{FileDiscovery, PyprojectDiscovery};
+use crate::settings::flags;
 use crate::settings::types::SerializationFormat;
+use crate::{packages, resolver};
 
 /// Run the linter over a collection of files.
 pub fn run(
@@ -27,24 +28,37 @@ pub fn run(
     pyproject_strategy: &PyprojectDiscovery,
     file_strategy: &FileDiscovery,
     overrides: &Overrides,
-    cache: bool,
-    autofix: &fixer::Mode,
+    cache: flags::Cache,
+    autofix: fixer::Mode,
 ) -> Result<Diagnostics> {
-    // Collect all the files to check.
+    // Collect all the Python files to check.
     let start = Instant::now();
     let (paths, resolver) =
         resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;
     let duration = start.elapsed();
     debug!("Identified files to lint in: {:?}", duration);
 
+    // Discover the package root for each Python file.
+    let package_roots = packages::detect_package_roots(
+        &paths
+            .iter()
+            .flatten()
+            .map(ignore::DirEntry::path)
+            .collect::<Vec<_>>(),
+    );
+
     let start = Instant::now();
     let mut diagnostics: Diagnostics = par_iter(&paths)
         .map(|entry| {
             match entry {
                 Ok(entry) => {
                     let path = entry.path();
+                    let package = path
+                        .parent()
+                        .and_then(|parent| package_roots.get(parent))
+                        .and_then(|package| *package);
                     let settings = resolver.resolve(path, pyproject_strategy);
-                    lint_path(path, settings, &cache.into(), autofix)
+                    lint_path(path, package, settings, cache, autofix)
                         .map_err(|e| (Some(path.to_owned()), e.to_string()))
                 }
                 Err(e) => Err((
@@ -102,7 +116,7 @@ fn read_from_stdin() -> Result<String> {
 pub fn run_stdin(
     strategy: &PyprojectDiscovery,
     filename: &Path,
-    autofix: &fixer::Mode,
+    autofix: fixer::Mode,
 ) -> Result<Diagnostics> {
     let stdin = read_from_stdin()?;
     let settings = match strategy {

src/directives.rs

@@ -37,6 +37,7 @@ pub struct IsortDirectives {
 }
 
 pub struct Directives {
+    pub commented_lines: Vec<usize>,
     pub noqa_line_for: IntMap<usize, usize>,
     pub isort: IsortDirectives,
 }
@@ -47,6 +48,7 @@ pub fn extract_directives(
     flags: Flags,
 ) -> Directives {
     Directives {
+        commented_lines: extract_commented_lines(lxr),
         noqa_line_for: if flags.contains(Flags::NOQA) {
             extract_noqa_line_for(lxr)
         } else {
@@ -60,6 +62,16 @@ pub fn extract_directives(
     }
 }
 
+pub fn extract_commented_lines(lxr: &[LexResult]) -> Vec<usize> {
+    let mut commented_lines = Vec::new();
+    for (start, tok, ..) in lxr.iter().flatten() {
+        if matches!(tok, Tok::Comment) {
+            commented_lines.push(start.row());
+        }
+    }
+    commented_lines
+}
+
 /// Extract a mapping from logical line to noqa line.
 pub fn extract_noqa_line_for(lxr: &[LexResult]) -> IntMap<usize, usize> {
     let mut noqa_line_for: IntMap<usize, usize> = IntMap::default();

src/flake8_2020/plugins.rs

@@ -3,7 +3,7 @@ use rustpython_ast::{Cmpop, Constant, Expr, ExprKind, Located};
 
 use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 
 fn is_sys(checker: &Checker, expr: &Expr, target: &str) -> bool {

src/flake8_annotations/helpers.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Arguments, Expr, Stmt, StmtKind};
 
 use crate::ast::cast;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::visibility;
 

src/flake8_annotations/plugins.rs

@@ -4,7 +4,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 use crate::ast::types::Range;
 use crate::ast::visitor::Visitor;
 use crate::ast::{cast, visitor};
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{CheckCode, CheckKind};
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::flake8_annotations::fixes;

src/flake8_blind_except/plugins.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// BLE001

src/flake8_boolean_trap/plugins.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Arguments, ExprKind};
 use rustpython_parser::ast::{Constant, Expr};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 const FUNC_NAME_ALLOWLIST: &[&str] = &["get", "setdefault", "pop", "fromkeys"];

src/flake8_bugbear/plugins/abstract_base_class.rs

@@ -3,7 +3,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
 
 use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 
 fn is_abc_class(

src/flake8_bugbear/plugins/assert_false.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, Stmt
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::code_gen::SourceGenerator;
 

src/flake8_bugbear/plugins/assert_raises_exception.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{ExprKind, Stmt, Withitem};
 
 use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B017

src/flake8_bugbear/plugins/assignment_to_os_environ.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B003

src/flake8_bugbear/plugins/cached_instance_method.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
 use crate::ast::types::{Range, ScopeKind};
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 fn is_cache_func(checker: &Checker, expr: &Expr) -> bool {

src/flake8_bugbear/plugins/cannot_raise_literal.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B016

src/flake8_bugbear/plugins/duplicate_exceptions.rs

@@ -7,7 +7,7 @@ use rustpython_ast::{
 use crate::ast::helpers;
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::code_gen::SourceGenerator;
 
@@ -56,9 +56,12 @@ fn duplicate_handler_exceptions<'a>(
                 Range::from_located(expr),
             );
             if checker.patch(check.kind.code()) {
-                // TODO(charlie): If we have a single element, remove the tuple.
                 let mut generator = SourceGenerator::new();
-                generator.unparse_expr(&type_pattern(unique_elts), 0);
+                if unique_elts.len() == 1 {
+                    generator.unparse_expr(unique_elts[0], 0);
+                } else {
+                    generator.unparse_expr(&type_pattern(unique_elts), 0);
+                }
                 if let Ok(content) = generator.generate() {
                     check.amend(Fix::replacement(
                         content,

src/flake8_bugbear/plugins/f_string_docstring.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B021

src/flake8_bugbear/plugins/function_call_argument_default.rs

@@ -7,7 +7,7 @@ use crate::ast::helpers::{
 use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::flake8_bugbear::plugins::mutable_argument_default::is_mutable_func;
 

src/flake8_bugbear/plugins/function_uses_loop_variable.rs

@@ -5,7 +5,7 @@ use crate::ast::helpers::collect_arg_names;
 use crate::ast::types::{Node, Range};
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 #[derive(Default)]

src/flake8_bugbear/plugins/getattr_with_constant.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::code_gen::SourceGenerator;
 use crate::python::identifiers::IDENTIFIER_REGEX;

src/flake8_bugbear/plugins/jump_statement_in_finally.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 fn walk_stmt(checker: &mut Checker, body: &[Stmt], f: fn(&Stmt) -> bool) {

src/flake8_bugbear/plugins/loop_variable_overrides_iterator.rs

@@ -4,7 +4,7 @@ use rustpython_ast::{Expr, ExprKind};
 use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 #[derive(Default)]

src/flake8_bugbear/plugins/mutable_argument_default.rs

@@ -3,7 +3,7 @@ use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Operator};
 
 use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 const MUTABLE_FUNCS: &[(&str, &str)] = &[

src/flake8_bugbear/plugins/raise_without_from_inside_except.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::ast::visitor::Visitor;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::python::string::is_lower;
 

src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs

@@ -1,52 +1,10 @@
-use anyhow::{bail, Result};
-use log::error;
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind, Located};
-use rustpython_parser::lexer;
-use rustpython_parser::lexer::Tok;
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
 
-use crate::ast::helpers;
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::code_gen::SourceGenerator;
-use crate::SourceCodeLocator;
-
-/// Given a statement like `except (ValueError,)`, find the range of the
-/// parenthesized expression.
-fn match_tuple_range<T>(located: &Located<T>, locator: &SourceCodeLocator) -> Result<Range> {
-    // Extract contents from the source code.
-    let range = Range::from_located(located);
-    let contents = locator.slice_source_code_range(&range);
-
-    // Find the left (opening) and right (closing) parentheses.
-    let mut location = None;
-    let mut end_location = None;
-    let mut count: usize = 0;
-    for (start, tok, end) in lexer::make_tokenizer(&contents).flatten() {
-        if matches!(tok, Tok::Lpar) {
-            if count == 0 {
-                location = Some(helpers::to_absolute(start, range.location));
-            }
-            count += 1;
-        }
-
-        if matches!(tok, Tok::Rpar) {
-            count -= 1;
-            if count == 0 {
-                end_location = Some(helpers::to_absolute(end, range.location));
-                break;
-            }
-        }
-    }
-    let (Some(location), Some(end_location)) = (location, end_location) else {
-        bail!("Unable to find left and right parentheses");
-    };
-    Ok(Range {
-        location,
-        end_location,
-    })
-}
 
 /// B013
 pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[Excepthandler]) {
@@ -68,16 +26,11 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
             let mut generator = SourceGenerator::new();
             generator.unparse_expr(elt, 0);
             if let Ok(content) = generator.generate() {
-                match match_tuple_range(handler, checker.locator) {
-                    Ok(range) => {
-                        check.amend(Fix::replacement(
-                            content,
-                            range.location,
-                            range.end_location,
-                        ));
-                    }
-                    Err(e) => error!("Failed to locate parentheses: {e}"),
-                }
+                check.amend(Fix::replacement(
+                    content,
+                    type_.location,
+                    type_.end_location.unwrap(),
+                ));
             }
         }
         checker.add_check(check);

src/flake8_bugbear/plugins/setattr_with_constant.rs

@@ -4,7 +4,7 @@ use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, Stmt
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::code_gen::SourceGenerator;
 use crate::python::identifiers::IDENTIFIER_REGEX;

src/flake8_bugbear/plugins/star_arg_unpacking_after_keyword_arg.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind, Keyword};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B026

src/flake8_bugbear/plugins/strip_with_multi_characters.rs

@@ -2,7 +2,7 @@ use itertools::Itertools;
 use rustpython_ast::{Constant, Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B005

src/flake8_bugbear/plugins/unary_prefix_increment.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind, Unaryop};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B002

src/flake8_bugbear/plugins/unreliable_callable_check.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Constant, Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B004

src/flake8_bugbear/plugins/unused_loop_control_variable.rs

@@ -5,7 +5,7 @@ use crate::ast::types::Range;
 use crate::ast::visitor;
 use crate::ast::visitor::Visitor;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// Identify all `ExprKind::Name` nodes in an AST.

src/flake8_bugbear/plugins/useless_comparison.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 pub fn useless_comparison(checker: &mut Checker, expr: &Expr) {

src/flake8_bugbear/plugins/useless_contextlib_suppress.rs

@@ -2,7 +2,7 @@ use rustpython_ast::Expr;
 
 use crate::ast::helpers::{collect_call_paths, match_call_path};
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B005

src/flake8_bugbear/plugins/useless_expression.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Constant, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 // B018

src/flake8_bugbear/plugins/zip_without_explicit_strict.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind, Keyword};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// B905

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__B013_B013.py.snap

@@ -6,10 +6,10 @@ expression: checks
     RedundantTupleInExceptionHandler: ValueError
   location:
     row: 3
-    column: 8
+    column: 7
   end_location:
     row: 3
-    column: 19
+    column: 20
   fix:
     content: ValueError
     location:

src/flake8_bugbear/snapshots/ruff__flake8_bugbear__tests__B014_B014.py.snap

@@ -7,50 +7,50 @@ expression: checks
       - OSError
   location:
     row: 17
-    column: 8
+    column: 7
   end_location:
     row: 17
-    column: 24
+    column: 25
   fix:
-    content: "OSError,"
+    content: OSError
     location:
       row: 17
-      column: 8
+      column: 7
     end_location:
       row: 17
-      column: 24
+      column: 25
 - kind:
     DuplicateHandlerException:
       - MyError
   location:
     row: 28
-    column: 8
+    column: 7
   end_location:
     row: 28
-    column: 24
+    column: 25
   fix:
-    content: "MyError,"
+    content: MyError
     location:
       row: 28
-      column: 8
+      column: 7
     end_location:
       row: 28
-      column: 24
+      column: 25
 - kind:
     DuplicateHandlerException:
       - re.error
   location:
     row: 49
-    column: 8
+    column: 7
   end_location:
     row: 49
-    column: 26
+    column: 27
   fix:
-    content: "re.error,"
+    content: re.error
     location:
       row: 49
-      column: 8
+      column: 7
     end_location:
       row: 49
-      column: 26
+      column: 27
 

src/flake8_print/plugins/print_call.rs

@@ -3,7 +3,7 @@ use rustpython_ast::{Expr, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::autofix::helpers;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::CheckCode;
 use crate::flake8_print::checks;
 

src/flake8_return/plugins.rs

@@ -5,7 +5,7 @@ use crate::ast::types::Range;
 use crate::ast::visitor::Visitor;
 use crate::ast::whitespace::indentation;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Branch, CheckCode, CheckKind};
 use crate::flake8_return::helpers::result_exists;
 use crate::flake8_return::visitor::{ReturnVisitor, Stack};

src/flake8_simplify/plugins/key_in_dict.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Cmpop, Expr, ExprKind};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 
 /// SIM118

src/flake8_unused_arguments/plugins.rs

@@ -7,7 +7,7 @@ use rustpython_ast::{Arg, Arguments};
 use crate::ast::function_type;
 use crate::ast::function_type::FunctionType;
 use crate::ast::types::{Binding, BindingKind, FunctionDef, Lambda, Scope, ScopeKind};
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::flake8_unused_arguments::helpers;
 use crate::flake8_unused_arguments::types::Argumentable;
 use crate::{visibility, Check};

src/fs.rs

@@ -40,7 +40,8 @@ pub(crate) fn ignores_from_path<'a>(
 
 /// Convert any path to an absolute path (based on the current working
 /// directory).
-pub fn normalize_path(path: &Path) -> PathBuf {
+pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
+    let path = path.as_ref();
     if let Ok(path) = path.absolutize() {
         return path.to_path_buf();
     }
@@ -48,8 +49,9 @@ pub fn normalize_path(path: &Path) -> PathBuf {
 }
 
 /// Convert any path to an absolute path (based on the specified project root).
-pub fn normalize_path_to(path: &Path, project_root: &Path) -> PathBuf {
-    if let Ok(path) = path.absolutize_from(project_root) {
+pub fn normalize_path_to<P: AsRef<Path>, R: AsRef<Path>>(path: P, project_root: R) -> PathBuf {
+    let path = path.as_ref();
+    if let Ok(path) = path.absolutize_from(project_root.as_ref()) {
         return path.to_path_buf();
     }
     path.to_path_buf()
@@ -64,7 +66,7 @@ pub fn relativize_path(path: &Path) -> Cow<str> {
 }
 
 /// Read a file's contents from disk.
-pub(crate) fn read_file(path: &Path) -> Result<String> {
+pub(crate) fn read_file<P: AsRef<Path>>(path: P) -> Result<String> {
     let file = File::open(path)?;
     let mut buf_reader = BufReader::new(file);
     let mut contents = String::new();

src/isort/categorize.rs

@@ -1,6 +1,8 @@
 use std::collections::BTreeSet;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+
+use log::debug;
 
 use crate::python::sys::KNOWN_STANDARD_LIBRARY;
 
@@ -13,45 +15,72 @@ pub enum ImportType {
     LocalFolder,
 }
 
+#[derive(Debug)]
+enum Reason<'a> {
+    NonZeroLevel,
+    KnownFirstParty,
+    KnownThirdParty,
+    ExtraStandardLibrary,
+    Future,
+    KnownStandardLibrary,
+    SamePackage,
+    SourceMatch(&'a Path),
+    NoMatch,
+}
+
 pub fn categorize(
     module_base: &str,
     level: Option<&usize>,
     src: &[PathBuf],
+    package: Option<&Path>,
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
 ) -> ImportType {
-    if level.map_or(false, |level| *level > 0) {
-        ImportType::LocalFolder
-    } else if known_first_party.contains(module_base) {
-        ImportType::FirstParty
-    } else if known_third_party.contains(module_base) {
-        ImportType::ThirdParty
-    } else if extra_standard_library.contains(module_base) {
-        ImportType::StandardLibrary
-    } else if module_base == "__future__" {
-        ImportType::Future
-    } else if KNOWN_STANDARD_LIBRARY.contains(module_base) {
-        ImportType::StandardLibrary
-    } else if find_local(src, module_base) {
-        ImportType::FirstParty
-    } else {
-        ImportType::ThirdParty
-    }
+    let (import_type, reason) = {
+        if level.map_or(false, |level| *level > 0) {
+            (ImportType::LocalFolder, Reason::NonZeroLevel)
+        } else if known_first_party.contains(module_base) {
+            (ImportType::FirstParty, Reason::KnownFirstParty)
+        } else if known_third_party.contains(module_base) {
+            (ImportType::ThirdParty, Reason::KnownThirdParty)
+        } else if extra_standard_library.contains(module_base) {
+            (ImportType::StandardLibrary, Reason::ExtraStandardLibrary)
+        } else if module_base == "__future__" {
+            (ImportType::Future, Reason::Future)
+        } else if KNOWN_STANDARD_LIBRARY.contains(module_base) {
+            (ImportType::StandardLibrary, Reason::KnownStandardLibrary)
+        } else if same_package(package, module_base) {
+            (ImportType::FirstParty, Reason::SamePackage)
+        } else if let Some(src) = match_sources(src, module_base) {
+            (ImportType::FirstParty, Reason::SourceMatch(src))
+        } else {
+            (ImportType::ThirdParty, Reason::NoMatch)
+        }
+    };
+    debug!(
+        "Categorized '{}' as {:?} ({:?})",
+        module_base, import_type, reason
+    );
+    import_type
 }
 
-fn find_local(paths: &[PathBuf], base: &str) -> bool {
+fn same_package(package: Option<&Path>, module_base: &str) -> bool {
+    package.map_or(false, |package| package.ends_with(module_base))
+}
+
+fn match_sources<'a>(paths: &'a [PathBuf], base: &str) -> Option<&'a Path> {
     for path in paths {
         if let Ok(metadata) = fs::metadata(path.join(base)) {
             if metadata.is_dir() {
-                return true;
+                return Some(path);
             }
         }
         if let Ok(metadata) = fs::metadata(path.join(format!("{base}.py"))) {
             if metadata.is_file() {
-                return true;
+                return Some(path);
             }
         }
     }
-    false
+    None
 }

src/isort/mod.rs

@@ -1,6 +1,6 @@
 use std::cmp::Reverse;
 use std::collections::{BTreeMap, BTreeSet};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use itertools::Itertools;
 use ropey::RopeBuilder;
@@ -294,6 +294,7 @@ fn normalize_imports(imports: Vec<AnnotatedImport>, combine_as_imports: bool) ->
 fn categorize_imports<'a>(
     block: ImportBlock<'a>,
     src: &[PathBuf],
+    package: Option<&Path>,
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
@@ -305,6 +306,7 @@ fn categorize_imports<'a>(
             &alias.module_base(),
             None,
             src,
+            package,
             known_first_party,
             known_third_party,
             extra_standard_library,
@@ -321,6 +323,7 @@ fn categorize_imports<'a>(
             &import_from.module_base(),
             import_from.level,
             src,
+            package,
             known_first_party,
             known_third_party,
             extra_standard_library,
@@ -337,6 +340,7 @@ fn categorize_imports<'a>(
             &import_from.module_base(),
             import_from.level,
             src,
+            package,
             known_first_party,
             known_third_party,
             extra_standard_library,
@@ -353,6 +357,7 @@ fn categorize_imports<'a>(
             &import_from.module_base(),
             import_from.level,
             src,
+            package,
             known_first_party,
             known_third_party,
             extra_standard_library,
@@ -470,6 +475,7 @@ pub fn format_imports(
     comments: Vec<Comment>,
     line_length: usize,
     src: &[PathBuf],
+    package: Option<&Path>,
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
@@ -486,6 +492,7 @@ pub fn format_imports(
     let block_by_type = categorize_imports(
         block,
         src,
+        package,
         known_first_party,
         known_third_party,
         extra_standard_library,

src/isort/plugins.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use rustpython_ast::{Location, Stmt};
 use textwrap::{dedent, indent};
 
@@ -36,6 +38,7 @@ pub fn check_imports(
     locator: &SourceCodeLocator,
     settings: &Settings,
     autofix: flags::Autofix,
+    package: Option<&Path>,
 ) -> Option<Check> {
     let indentation = locator.slice_source_code_range(&extract_indentation_range(&block.imports));
     let indentation = leading_space(&indentation);
@@ -71,6 +74,7 @@ pub fn check_imports(
         comments,
         settings.line_length - indentation.len(),
         &settings.src,
+        package,
         &settings.isort.known_first_party,
         &settings.isort.known_third_party,
         &settings.isort.extra_standard_library,

src/lib.rs

@@ -29,10 +29,7 @@ use crate::source_code_locator::SourceCodeLocator;
 mod ast;
 pub mod autofix;
 pub mod cache;
-pub mod check_ast;
-mod check_imports;
-mod check_lines;
-mod check_tokens;
+mod checkers;
 pub mod checks;
 pub mod checks_gen;
 pub mod cli;
@@ -68,6 +65,7 @@ pub mod logging;
 pub mod mccabe;
 pub mod message;
 mod noqa;
+mod packages;
 mod pandas_vet;
 pub mod pep8_naming;
 pub mod printer;
@@ -123,6 +121,7 @@ pub fn check(path: &Path, contents: &str, autofix: bool) -> Result<Vec<Check>> {
     // Generate checks.
     let checks = check_path(
         path,
+        packages::detect_package_root(path),
         contents,
         tokens,
         &locator,

src/linter.rs

@@ -7,16 +7,16 @@ use std::path::Path;
 use anyhow::Result;
 #[cfg(not(target_family = "wasm"))]
 use log::debug;
-use nohash_hasher::IntMap;
 use rustpython_parser::lexer::LexResult;
 
 use crate::ast::types::Range;
 use crate::autofix::fixer;
 use crate::autofix::fixer::fix_file;
-use crate::check_ast::check_ast;
-use crate::check_imports::check_imports;
-use crate::check_lines::check_lines;
-use crate::check_tokens::check_tokens;
+use crate::checkers::ast::check_ast;
+use crate::checkers::imports::check_imports;
+use crate::checkers::lines::check_lines;
+use crate::checkers::noqa::check_noqa;
+use crate::checkers::tokens::check_tokens;
 use crate::checks::{Check, CheckCode, CheckKind, LintSource};
 use crate::code_gen::SourceGenerator;
 use crate::directives::Directives;
@@ -50,6 +50,7 @@ impl AddAssign for Diagnostics {
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_path(
     path: &Path,
+    package: Option<&Path>,
     contents: &str,
     tokens: Vec<LexResult>,
     locator: &SourceCodeLocator,
@@ -62,11 +63,11 @@ pub(crate) fn check_path(
     let mut checks: Vec<Check> = vec![];
 
     // Run the token-based checks.
-    let use_tokens = settings
+    if settings
         .enabled
         .iter()
-        .any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens));
-    if use_tokens {
+        .any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens))
+    {
         checks.extend(check_tokens(locator, &tokens, settings, autofix));
     }
 
@@ -101,6 +102,7 @@ pub(crate) fn check_path(
                         settings,
                         autofix,
                         path,
+                        package,
                     ));
                 }
             }
@@ -119,14 +121,35 @@ pub(crate) fn check_path(
     }
 
     // Run the lines-based checks.
-    check_lines(
-        &mut checks,
-        contents,
-        &directives.noqa_line_for,
-        settings,
-        autofix,
-        noqa,
-    );
+    if settings
+        .enabled
+        .iter()
+        .any(|check_code| matches!(check_code.lint_source(), LintSource::Lines))
+    {
+        checks.extend(check_lines(
+            contents,
+            &directives.commented_lines,
+            settings,
+            autofix,
+        ));
+    }
+
+    // Enforce `noqa` directives.
+    if matches!(noqa, flags::Noqa::Enabled)
+        || settings
+            .enabled
+            .iter()
+            .any(|check_code| matches!(check_code.lint_source(), LintSource::NoQA))
+    {
+        check_noqa(
+            &mut checks,
+            contents,
+            &directives.commented_lines,
+            &directives.noqa_line_for,
+            settings,
+            autofix,
+        );
+    }
 
     // Create path ignores.
     if !checks.is_empty() && !settings.per_file_ignores.is_empty() {
@@ -147,14 +170,15 @@ const MAX_ITERATIONS: usize = 100;
 /// Lint the source code at the given `Path`.
 pub fn lint_path(
     path: &Path,
+    package: Option<&Path>,
     settings: &Settings,
-    mode: &cache::Mode,
-    autofix: &fixer::Mode,
+    cache: flags::Cache,
+    autofix: fixer::Mode,
 ) -> Result<Diagnostics> {
     let metadata = path.metadata()?;
 
     // Check the cache.
-    if let Some(messages) = cache::get(path, &metadata, settings, autofix, mode) {
+    if let Some(messages) = cache::get(path, &metadata, settings, autofix, cache) {
         debug!("Cache hit for: {}", path.to_string_lossy());
         return Ok(Diagnostics::new(messages));
     }
@@ -163,10 +187,10 @@ pub fn lint_path(
     let contents = fs::read_file(path)?;
 
     // Lint the file.
-    let (contents, fixed, messages) = lint(contents, path, settings, autofix)?;
+    let (contents, fixed, messages) = lint(contents, path, package, settings, autofix)?;
 
     // Re-populate the cache.
-    cache::set(path, &metadata, settings, autofix, &messages, mode);
+    cache::set(path, &metadata, settings, autofix, &messages, cache);
 
     // If we applied any fixes, write the contents back to disk.
     if fixed > 0 {
@@ -197,13 +221,11 @@ pub fn add_noqa_to_path(path: &Path, settings: &Settings) -> Result<usize> {
     // Generate checks, ignoring any existing `noqa` directives.
     let checks = check_path(
         path,
+        None,
         &contents,
         tokens,
         &locator,
-        &Directives {
-            noqa_line_for: IntMap::default(),
-            isort: directives.isort,
-        },
+        &directives,
         settings,
         flags::Autofix::Disabled,
         flags::Noqa::Disabled,
@@ -241,13 +263,13 @@ pub fn lint_stdin(
     path: &Path,
     stdin: &str,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: fixer::Mode,
 ) -> Result<Diagnostics> {
     // Read the file from disk.
     let contents = stdin.to_string();
 
     // Lint the file.
-    let (contents, fixed, messages) = lint(contents, path, settings, autofix)?;
+    let (contents, fixed, messages) = lint(contents, path, None, settings, autofix)?;
 
     // Write the fixed contents to stdout.
     if matches!(autofix, fixer::Mode::Apply) {
@@ -260,8 +282,9 @@ pub fn lint_stdin(
 fn lint(
     mut contents: String,
     path: &Path,
+    package: Option<&Path>,
     settings: &Settings,
-    autofix: &fixer::Mode,
+    autofix: fixer::Mode,
 ) -> Result<(String, usize, Vec<Message>)> {
     // Track the number of fixed errors across iterations.
     let mut fixed = 0;
@@ -287,6 +310,7 @@ fn lint(
         // Generate checks.
         let checks = check_path(
             path,
+            package,
             &contents,
             tokens,
             &locator,
@@ -343,6 +367,7 @@ pub fn test_path(path: &Path, settings: &Settings) -> Result<Vec<Check>> {
     );
     check_path(
         path,
+        None,
         &contents,
         tokens,
         &locator,

src/logging.rs

@@ -1,6 +1,16 @@
 use anyhow::Result;
 use fern;
 
+#[macro_export]
+macro_rules! one_time_warning {
+    ($($arg:tt)*) => {
+        static WARNED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+        if !WARNED.swap(true, std::sync::atomic::Ordering::SeqCst) {
+            eprintln!($($arg)*);
+        }
+    };
+}
+
 #[macro_export]
 macro_rules! tell_user {
     ($($arg:tt)*) => {

src/main.rs

@@ -17,10 +17,10 @@ use std::process::ExitCode;
 use std::sync::mpsc::channel;
 
 use ::ruff::autofix::fixer;
-use ::ruff::cli::{extract_log_level, Cli};
+use ::ruff::cli::{extract_log_level, Cli, Overrides};
 use ::ruff::logging::{set_up_logging, LogLevel};
 use ::ruff::printer::Printer;
-use ::ruff::resolver::PyprojectDiscovery;
+use ::ruff::resolver::{resolve_settings, FileDiscovery, PyprojectDiscovery, Relativity};
 use ::ruff::settings::configuration::Configuration;
 use ::ruff::settings::types::SerializationFormat;
 use ::ruff::settings::{pyproject, Settings};
@@ -32,23 +32,30 @@ use clap::{CommandFactory, Parser};
 use colored::Colorize;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 use path_absolutize::path_dedot;
-use ruff::cli::Overrides;
-use ruff::resolver::{resolve_settings, FileDiscovery, Relativity};
 
 /// Resolve the relevant settings strategy and defaults for the current
 /// invocation.
-fn resolve(config: Option<PathBuf>, overrides: &Overrides) -> Result<PyprojectDiscovery> {
+fn resolve(
+    config: Option<&Path>,
+    overrides: &Overrides,
+    stdin_filename: Option<&Path>,
+) -> Result<PyprojectDiscovery> {
     if let Some(pyproject) = config {
         // First priority: the user specified a `pyproject.toml` file. Use that
         // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
         // current working directory. (This matches ESLint's behavior.)
-        let settings = resolve_settings(&pyproject, &Relativity::Cwd, Some(overrides))?;
+        let settings = resolve_settings(pyproject, &Relativity::Cwd, Some(overrides))?;
         Ok(PyprojectDiscovery::Fixed(settings))
-    } else if let Some(pyproject) = pyproject::find_pyproject_toml(path_dedot::CWD.as_path())? {
-        // Second priority: find a `pyproject.toml` file in the current working path,
-        // and resolve all paths relative to that directory. (With
-        // `Strategy::Hierarchical`, we'll end up finding the "closest" `pyproject.toml`
-        // file for every Python file later on, so these act as the "default" settings.)
+    } else if let Some(pyproject) = pyproject::find_pyproject_toml(
+        stdin_filename
+            .as_ref()
+            .unwrap_or(&path_dedot::CWD.as_path()),
+    )? {
+        // Second priority: find a `pyproject.toml` file in either an ancestor of
+        // `stdin_filename` (if set) or the current working path all paths relative to
+        // that directory. (With `Strategy::Hierarchical`, we'll end up finding
+        // the "closest" `pyproject.toml` file for every Python file later on,
+        // so these act as the "default" settings.)
         let settings = resolve_settings(&pyproject, &Relativity::Parent, Some(overrides))?;
         Ok(PyprojectDiscovery::Hierarchical(settings))
     } else if let Some(pyproject) = pyproject::find_user_pyproject_toml() {
@@ -87,7 +94,11 @@ fn inner_main() -> Result<ExitCode> {
 
     // Construct the "default" settings. These are used when no `pyproject.toml`
     // files are present, or files are injected from outside of the hierarchy.
-    let pyproject_strategy = resolve(cli.config, &overrides)?;
+    let pyproject_strategy = resolve(
+        cli.config.as_deref(),
+        &overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
 
     // Extract options that are included in `Settings`, but only apply at the top
     // level.
@@ -153,8 +164,8 @@ fn inner_main() -> Result<ExitCode> {
             &pyproject_strategy,
             &file_strategy,
             &overrides,
-            cache_enabled,
-            &fixer::Mode::None,
+            cache_enabled.into(),
+            fixer::Mode::None,
         )?;
         printer.write_continuously(&messages)?;
 
@@ -183,8 +194,8 @@ fn inner_main() -> Result<ExitCode> {
                             &pyproject_strategy,
                             &file_strategy,
                             &overrides,
-                            cache_enabled,
-                            &fixer::Mode::None,
+                            cache_enabled.into(),
+                            fixer::Mode::None,
                         )?;
                         printer.write_continuously(&messages)?;
                     }
@@ -209,17 +220,16 @@ fn inner_main() -> Result<ExitCode> {
 
         // Generate lint violations.
         let diagnostics = if is_stdin {
-            let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
-            let path = Path::new(&filename);
-            commands::run_stdin(&pyproject_strategy, path, &autofix)?
+            let path = cli.stdin_filename.unwrap_or_else(|| PathBuf::from("-"));
+            commands::run_stdin(&pyproject_strategy, &path, autofix)?
         } else {
             commands::run(
                 &cli.files,
                 &pyproject_strategy,
                 &file_strategy,
                 &overrides,
-                cache_enabled,
-                &autofix,
+                cache_enabled.into(),
+                autofix,
             )?
         };
 
@@ -227,7 +237,7 @@ fn inner_main() -> Result<ExitCode> {
         // unless we're writing fixes via stdin (in which case, the transformed
         // source code goes to stdout).
         if !(is_stdin && matches!(autofix, fixer::Mode::Apply)) {
-            printer.write_once(&diagnostics, &autofix)?;
+            printer.write_once(&diagnostics, autofix)?;
         }
 
         // Check for updates if we're in a non-silent log level.

src/packages.rs

@@ -0,0 +1,157 @@
+//! Detect Python package roots and file associations.
+
+use std::path::Path;
+
+use rustc_hash::FxHashMap;
+
+// If we have a Python package layout like:
+// - root/
+//   - foo/
+//     - __init__.py
+//     - bar.py
+//     - baz/
+//       - __init__.py
+//       - qux.py
+//
+// Then today, if you run with defaults (`src = ["."]`) from `root`, we'll
+// detect that `foo.bar`, `foo.baz`, and `foo.baz.qux` are first-party modules
+// (since, if you're in `root`, you can see `foo`).
+//
+// However, we'd also like it to be the case that, even if you run this command
+// from `foo`, we still consider `foo.baz.qux` to be first-party when linting
+// `foo/bar.py`. More specifically, for each Python file, we should find the
+// root of the current package.
+//
+// Thus, for each file, we iterate up its ancestors, returning the last
+// directory containing an `__init__.py`.
+
+/// Return `true` if the directory at the given `Path` appears to be a Python
+/// package.
+pub fn is_package(path: &Path) -> bool {
+    path.join("__init__.py").is_file()
+}
+
+/// Return the package root for the given Python file.
+pub fn detect_package_root(path: &Path) -> Option<&Path> {
+    let mut current = None;
+    for parent in path.ancestors() {
+        if !is_package(parent) {
+            return current;
+        }
+        current = Some(parent);
+    }
+    current
+}
+
+/// A wrapper around `is_package` to cache filesystem lookups.
+fn is_package_with_cache<'a>(
+    path: &'a Path,
+    package_cache: &mut FxHashMap<&'a Path, bool>,
+) -> bool {
+    *package_cache
+        .entry(path)
+        .or_insert_with(|| is_package(path))
+}
+
+/// A wrapper around `detect_package_root` to cache filesystem lookups.
+fn detect_package_root_with_cache<'a>(
+    path: &'a Path,
+    package_cache: &mut FxHashMap<&'a Path, bool>,
+) -> Option<&'a Path> {
+    let mut current = None;
+    for parent in path.ancestors() {
+        if !is_package_with_cache(parent, package_cache) {
+            return current;
+        }
+        current = Some(parent);
+    }
+    current
+}
+
+/// Return a mapping from Python file to its package root.
+pub fn detect_package_roots<'a>(files: &[&'a Path]) -> FxHashMap<&'a Path, Option<&'a Path>> {
+    // Pre-populate the module cache, since the list of files could (but isn't
+    // required to) contain some `__init__.py` files.
+    let mut package_cache: FxHashMap<&Path, bool> = FxHashMap::default();
+    for file in files {
+        if file.ends_with("__init__.py") {
+            if let Some(parent) = file.parent() {
+                package_cache.insert(parent, true);
+            }
+        }
+    }
+
+    // Search for the package root for each file.
+    let mut package_roots: FxHashMap<&Path, Option<&Path>> = FxHashMap::default();
+    for file in files {
+        if let Some(package) = file.parent() {
+            if package_roots.contains_key(package) {
+                continue;
+            }
+            package_roots.insert(
+                package,
+                detect_package_root_with_cache(package, &mut package_cache),
+            );
+        }
+    }
+
+    package_roots
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use crate::packages::detect_package_root;
+
+    #[test]
+    fn package_detection() {
+        assert_eq!(
+            detect_package_root(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/package/src/package")
+                    .as_path(),
+            ),
+            Some(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/package/src/package")
+                    .as_path()
+            )
+        );
+
+        assert_eq!(
+            detect_package_root(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/project/python_modules/core/core")
+                    .as_path(),
+            ),
+            Some(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/project/python_modules/core/core")
+                    .as_path()
+            )
+        );
+
+        assert_eq!(
+            detect_package_root(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/project/examples/docs/docs/concepts")
+                    .as_path(),
+            ),
+            Some(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("resources/test/project/examples/docs/docs")
+                    .as_path()
+            )
+        );
+
+        assert_eq!(
+            detect_package_root(
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("setup.py")
+                    .as_path(),
+            ),
+            None,
+        );
+    }
+}

src/pandas_vet/mod.rs

@@ -28,6 +28,7 @@ mod tests {
         );
         let mut checks = check_path(
             Path::new("<filename>"),
+            None,
             &contents,
             tokens,
             &locator,

src/pep8_naming/plugins.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, Stmt};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::CheckKind;
 use crate::pep8_naming::helpers;
 use crate::Check;

src/printer.rs

@@ -57,7 +57,7 @@ impl<'a> Printer<'a> {
         }
     }
 
-    fn post_text(&self, num_fixable: usize, autofix: &fixer::Mode) {
+    fn post_text(&self, num_fixable: usize, autofix: fixer::Mode) {
         if self.log_level >= &LogLevel::Default {
             if num_fixable > 0 && !matches!(autofix, fixer::Mode::Apply) {
                 println!("{num_fixable} potentially fixable with the --fix option.");
@@ -65,7 +65,7 @@ impl<'a> Printer<'a> {
         }
     }
 
-    pub fn write_once(&self, diagnostics: &Diagnostics, autofix: &fixer::Mode) -> Result<()> {
+    pub fn write_once(&self, diagnostics: &Diagnostics, autofix: fixer::Mode) -> Result<()> {
         if matches!(self.log_level, LogLevel::Silent) {
             return Ok(());
         }

src/pycodestyle/checks.rs

@@ -1,4 +1,6 @@
 use itertools::izip;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use rustpython_ast::{Located, Location, Stmt, StmtKind};
 use rustpython_parser::ast::{Cmpop, Expr, ExprKind};
 
@@ -6,6 +8,37 @@ use crate::ast::types::Range;
 use crate::checks::{Check, CheckKind};
 use crate::source_code_locator::SourceCodeLocator;
 
+static URL_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^https?://\S+$").unwrap());
+
+/// E501
+pub fn line_too_long(lineno: usize, line: &str, max_line_length: usize) -> Option<Check> {
+    let line_length = line.chars().count();
+
+    if line_length <= max_line_length {
+        return None;
+    }
+
+    let mut chunks = line.split_whitespace();
+    let (Some(first), Some(_)) = (chunks.next(), chunks.next()) else {
+        // Single word / no printable chars - no way to make the line shorter
+        return None;
+    };
+
+    // Do not enforce the line length for commented lines that end with a URL
+    // or contain only a single word.
+    if first == "#" && chunks.last().map_or(true, |c| URL_REGEX.is_match(c)) {
+        return None;
+    }
+
+    Some(Check::new(
+        CheckKind::LineTooLong(line_length, max_line_length),
+        Range {
+            location: Location::new(lineno + 1, max_line_length),
+            end_location: Location::new(lineno + 1, line_length),
+        },
+    ))
+}
+
 /// E721
 pub fn type_comparison(ops: &[Cmpop], comparators: &[Expr], location: Range) -> Vec<Check> {
     let mut checks: Vec<Check> = vec![];
@@ -100,6 +133,24 @@ pub fn ambiguous_function_name(name: &str, location: Range) -> Option<Check> {
     }
 }
 
+/// W292
+pub fn no_newline_at_end_of_file(contents: &str) -> Option<Check> {
+    if !contents.ends_with('\n') {
+        // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't
+        // want to raise W292 anyway).
+        if let Some(line) = contents.lines().last() {
+            return Some(Check::new(
+                CheckKind::NoNewLineAtEndOfFile,
+                Range {
+                    location: Location::new(contents.lines().count(), line.len() + 1),
+                    end_location: Location::new(contents.lines().count(), line.len() + 1),
+                },
+            ));
+        }
+    }
+    None
+}
+
 // See: https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals
 const VALID_ESCAPE_SEQUENCES: &[char; 23] = &[
     '\n', '\\', '\'', '"', 'a', 'b', 'f', 'n', 'r', 't', 'v', '0', '1', '2', '3', '4', '5', '6',

src/pycodestyle/plugins.rs

@@ -10,7 +10,7 @@ use crate::ast::helpers::{match_leading_content, match_trailing_content};
 use crate::ast::types::Range;
 use crate::ast::whitespace::leading_space;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind, RejectedCmpop};
 use crate::code_gen::SourceGenerator;
 

src/pycodestyle/snapshots/ruff__pycodestyle__tests__E501_E501.py.snap

@@ -46,4 +46,15 @@ expression: checks
     row: 43
     column: 105
   fix: ~
+- kind:
+    LineTooLong:
+      - 129
+      - 88
+  location:
+    row: 61
+    column: 88
+  end_location:
+    row: 61
+    column: 129
+  fix: ~
 

src/pydocstyle/plugins.rs

@@ -8,7 +8,7 @@ use crate::ast::types::Range;
 use crate::ast::whitespace::LinesWithTrailingNewline;
 use crate::ast::{cast, whitespace};
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::docstrings::constants;
 use crate::docstrings::definition::{Definition, DefinitionKind, Docstring};

src/pyflakes/mod.rs

@@ -177,6 +177,7 @@ mod tests {
         );
         let mut checks = check_path(
             Path::new("<filename>"),
+            None,
             &contents,
             tokens,
             &locator,

src/pyflakes/plugins/assert_tuple.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, Stmt};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::pyflakes::checks;
 
 /// F631

src/pyflakes/plugins/if_tuple.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, Stmt};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::pyflakes::checks;
 
 /// F634

src/pyflakes/plugins/invalid_literal_comparisons.rs

@@ -6,7 +6,7 @@ use crate::ast::helpers;
 use crate::ast::operations::locate_cmpops;
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// F632

src/pyflakes/plugins/invalid_print_syntax.rs

@@ -1,7 +1,7 @@
 use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 /// F633

src/pyflakes/plugins/raise_not_implemented.rs

@@ -2,7 +2,7 @@ use rustpython_ast::{Expr, ExprKind};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 fn match_not_implemented(expr: &Expr) -> Option<&Expr> {

src/pyflakes/plugins/strings.rs

@@ -5,7 +5,7 @@ use rustpython_ast::{Keyword, KeywordData};
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
 use crate::ast::types::Range;
-use crate::check_ast::Checker;
+use crate::checkers::ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::pyflakes::cformat::CFormatSummary;
 use crate::pyflakes::fixes::{

src/pygrep_hooks/mod.rs

@@ -1,4 +1,4 @@
-pub mod checks;
+pub mod plugins;
 
 #[cfg(test)]
 mod tests {
@@ -14,6 +14,9 @@ mod tests {
 
     #[test_case(CheckCode::PGH001, Path::new("PGH001_0.py"); "PGH001_0")]
     #[test_case(CheckCode::PGH001, Path::new("PGH001_1.py"); "PGH001_1")]
+    #[test_case(CheckCode::PGH002, Path::new("PGH002_0.py"); "PGH002_0")]
+    #[test_case(CheckCode::PGH002, Path::new("PGH002_1.py"); "PGH002_1")]
+    #[test_case(CheckCode::PGH003, Path::new("PGH003_0.py"); "PGH003_0")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(

src/pygrep_hooks/plugins/blanket_type_ignore.rs

@@ -0,0 +1,22 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+use rustpython_ast::Location;
+
+use crate::ast::types::Range;
+use crate::checks::{Check, CheckKind};
+
+static BLANKET_TYPE_IGNORE_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"# type:? *ignore($|\s)").unwrap());
+
+/// PGH003 - use of blanket type ignore comments
+pub fn blanket_type_ignore(lineno: usize, line: &str) -> Option<Check> {
+    BLANKET_TYPE_IGNORE_REGEX.find(line).map(|m| {
+        Check::new(
+            CheckKind::BlanketTypeIgnore,
+            Range {
+                location: Location::new(lineno + 1, m.start()),
+                end_location: Location::new(lineno + 1, m.end()),
+            },
+        )
+    })
+}

src/pygrep_hooks/plugins/deprecated_log_warn.rs

@@ -0,0 +1,19 @@
+use rustpython_ast::Expr;
+
+use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
+use crate::ast::types::Range;
+use crate::checkers::ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// PGH002 - deprecated use of logging.warn
+pub fn deprecated_log_warn(checker: &mut Checker, func: &Expr) {
+    let call_path = dealias_call_path(collect_call_paths(func), &checker.import_aliases);
+    if call_path == ["log", "warn"]
+        || match_call_path(&call_path, "logging", "warn", &checker.from_imports)
+    {
+        checker.add_check(Check::new(
+            CheckKind::DeprecatedLogWarn,
+            Range::from_located(func),
+        ));
+    }
+}