python-linters 0.2.0__tar.gz → 0.2.2__tar.gz

{python_linters-0.2.0 → python_linters-0.2.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: python-linters
-Version: 0.2.0
+Version: 0.2.2
 Summary: Run ruff, ty and pymodularity on a Python project and print one JSON report grouped by rule.
 Author: Tilo Himmelsbach
 License-Expression: MIT
-Requires-Dist: ruff==0.17.3
-Requires-Dist: ty==0.0.90
+Requires-Dist: ruff==0.17.5
+Requires-Dist: ty==0.0.103
 Requires-Dist: pymodularity==0.5.0
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -25,9 +25,9 @@ uv add --dev python-linters
 
 ## Commands
 
-- `uv run python-linters lint [path] [--out FILE]` — runs ruff, ty and
-  pymodularity (default path: `.`) and prints the merged JSON report to
-  stdout, or writes it to `FILE` with `--out`.
+- `uv run python-linters lint [path] [--out FILE]` — runs ruff, `ruff
+  format --check`, ty and pymodularity (default path: `.`) and prints the
+  merged JSON report to stdout, or writes it to `FILE` with `--out`.
 - `uv run python-linters reference ruff|ty` — prints this package's shipped
   reference config for the given tool to stdout. The package never writes
   it into your project — copying it into `ruff.toml`/`ty.toml` (or

{python_linters-0.2.0 → python_linters-0.2.2}/README.md

@@ -13,9 +13,9 @@ uv add --dev python-linters
 
 ## Commands
 
-- `uv run python-linters lint [path] [--out FILE]` — runs ruff, ty and
-  pymodularity (default path: `.`) and prints the merged JSON report to
-  stdout, or writes it to `FILE` with `--out`.
+- `uv run python-linters lint [path] [--out FILE]` — runs ruff, `ruff
+  format --check`, ty and pymodularity (default path: `.`) and prints the
+  merged JSON report to stdout, or writes it to `FILE` with `--out`.
 - `uv run python-linters reference ruff|ty` — prints this package's shipped
   reference config for the given tool to stdout. The package never writes
   it into your project — copying it into `ruff.toml`/`ty.toml` (or

{python_linters-0.2.0 → python_linters-0.2.2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "python-linters"
-version = "0.2.0"
+version = "0.2.2"
 description = "Run ruff, ty and pymodularity on a Python project and print one JSON report grouped by rule."
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11"
 dependencies = [
-    "ruff==0.17.3",
-    "ty==0.0.90",
+    "ruff==0.17.5",
+    "ty==0.0.103",
     "pymodularity==0.5.0",
 ]
 

{python_linters-0.2.0 → python_linters-0.2.2}/pyproject.toml.orig

@@ -1,14 +1,14 @@
 [project]
 name = "python-linters"
-version = "0.2.0"
+version = "0.2.2"
 description = "Run ruff, ty and pymodularity on a Python project and print one JSON report grouped by rule."
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11"
 authors = [{ name = "Tilo Himmelsbach" }]
 dependencies = [
-    "ruff==0.17.3",
-    "ty==0.0.90",
+    "ruff==0.17.5",
+    "ty==0.0.103",
     "pymodularity==0.5.0",
 ]
 

{python_linters-0.2.0 → python_linters-0.2.2}/src/python_linters/config_check.py

@@ -169,7 +169,9 @@ def _covers_rule(
         return False
     if selector in meta_prefixes:
         return True
-    selector_linters = {r["linter"] for r in rules if r["code"] and r["code"].startswith(selector)}
+    selector_linters = {
+        r["linter"] for r in rules if r["code"] and r["code"].startswith(selector)
+    }
     return selector_linters == {linter}
 
 
@@ -221,9 +223,14 @@ def _get_new_categories(
     for prefix, linter in sorted(categories.items()):
         if any(_covers(k, prefix, category_linters, meta_prefixes) for k in known):
             continue
-        prefix_rules = [r for r in rules if r["code"] and r["code"].rstrip(string.digits) == prefix]
+        prefix_rules = [
+            r for r in rules if r["code"] and r["code"].rstrip(string.digits) == prefix
+        ]
         if all(
-            any(_covers_rule(k, r["code"], r["linter"], rules, meta_prefixes) for k in known)
+            any(
+                _covers_rule(k, r["code"], r["linter"], rules, meta_prefixes)
+                for k in known
+            )
             for r in prefix_rules
         ):
             continue
@@ -255,9 +262,13 @@ def check_ruff_config(toml_path: Path) -> RuffConfigCheck:
     commented = _parse_toml_comments(toml_path)
 
     known = selected | commented
-    meta_prefixes = {"PL"} | {p for p, linters in category_linters.items() if len(linters) > 1}
+    meta_prefixes = {"PL"} | {
+        p for p, linters in category_linters.items() if len(linters) > 1
+    }
 
-    new_categories = _get_new_categories(rules, categories, category_linters, known, meta_prefixes)
+    new_categories = _get_new_categories(
+        rules, categories, category_linters, known, meta_prefixes
+    )
     removed = _get_removed(rules, selected)
 
     untriaged_codeless = [n for n in _get_codeless_rules(rules) if n not in known]
@@ -293,24 +304,36 @@ def format_ruff_report(toml_path: Path, check: RuffConfigCheck) -> str:
     if check.new_categories:
         lines.append(f"NEW categories not yet triaged ({len(check.new_categories)}):")
         lines.append("  Add to select or comment out with '# excluded' in ruff.toml:\n")
-        lines.extend(f'    "{prefix}",\t# {linter}' for prefix, linter in check.new_categories)
+        lines.extend(
+            f'    "{prefix}",\t# {linter}' for prefix, linter in check.new_categories
+        )
         lines.append("")
 
     if check.removed:
-        lines.append(f"REMOVED/RENAMED categories still in select ({len(check.removed)}):")
+        lines.append(
+            f"REMOVED/RENAMED categories still in select ({len(check.removed)}):"
+        )
         lines.extend(f"    {code}" for code in check.removed)
         lines.append("")
 
     if check.untriaged_codeless:
-        lines.append(f"Code-less rules not yet triaged ({len(check.untriaged_codeless)}):")
-        lines.append("  Add to select by name or comment out with '# excluded' in ruff.toml:\n")
+        lines.append(
+            f"Code-less rules not yet triaged ({len(check.untriaged_codeless)}):"
+        )
+        lines.append(
+            "  Add to select by name or comment out with '# excluded' in ruff.toml:\n"
+        )
         lines.extend(f'    "{name}",' for name in check.untriaged_codeless)
         lines.append("")
 
     if check.untriaged_preview:
         lines.append(f"Preview rules not yet triaged ({len(check.untriaged_preview)}):")
-        lines.append("  Add to select by name or cover with an '# excluded' line in ruff.toml:\n")
-        lines.extend(f'    "{name}",\t# {code}' for code, name in check.untriaged_preview)
+        lines.append(
+            "  Add to select by name or cover with an '# excluded' line in ruff.toml:\n"
+        )
+        lines.extend(
+            f'    "{name}",\t# {code}' for code, name in check.untriaged_preview
+        )
         lines.append("")
 
     if check.is_clean:
@@ -395,7 +418,9 @@ def format_ty_report(config_path: Path, check: TyConfigCheck) -> str:
     ]
 
     if check.untriaged:
-        lines.append(f"UNTRIAGED rules ty knows that the config omits ({len(check.untriaged)}):")
+        lines.append(
+            f"UNTRIAGED rules ty knows that the config omits ({len(check.untriaged)}):"
+        )
         lines.extend(
             f'    {name} = "???"  # default: {check.default_levels[name]}'
             for name in check.untriaged
@@ -403,7 +428,9 @@ def format_ty_report(config_path: Path, check: TyConfigCheck) -> str:
         lines.append("")
 
     if check.stale:
-        lines.append(f"STALE rules named in config that ty no longer knows ({len(check.stale)}):")
+        lines.append(
+            f"STALE rules named in config that ty no longer knows ({len(check.stale)}):"
+        )
         lines.extend(f"    {name}" for name in check.stale)
         lines.append("")
 

{python_linters-0.2.0 → python_linters-0.2.2}/src/python_linters/lint_report.py

@@ -1,4 +1,4 @@
-"""Run ruff, ty and pymodularity and group their findings by rule.
+"""Run ruff, ruff format --check, ty and pymodularity and group their findings by rule.
 
 Ported from lint_grouped.py (quality-and-security-tools howtos), minus eslint.
 
@@ -7,6 +7,7 @@ Output structure:
       "project": "/abs/path",
       "summary": {
         "ruff":        {"total": 100, "rules": 12},
+        "ruff-format": {"total": 2,   "rules": 1},
         "ty":          {"total": 50,  "rules": 8},
         "pymodularity": {"total": 5,  "rules": 2}
       },
@@ -17,6 +18,12 @@ Output structure:
           "locations": [{"file": "rel/path.py", "line": 12, "col": 5, "message": "..."}, ...]
         }
       },
+      "ruff-format": {
+        "unformatted": {
+          "count":     2,
+          "locations": [{"file": "rel/path.py", "line": 1, "col": 1, "message": "would be reformatted"}, ...]
+        }
+      },
       "ty": {
         "invalid-return-type": {
           "severity":  "major",
@@ -40,18 +47,23 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from python_linters.tool_errors import run_checked
+from python_linters.tool_errors import ToolFailedError, run_checked
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
 _TY_SEVERITY_MAP = {"major": "error", "minor": "warning", "info": "info"}
 
+# Matches ruff format --check's per-file location line, e.g.:
+#  --> my_package/main_module.py:1:2
+_RUFF_FORMAT_LOCATION_RE = re.compile(r"^ --> (?P<file>.+):(?P<line>\d+):(?P<col>\d+)$")
+
 
 @dataclass
 class Location:
@@ -61,7 +73,12 @@ class Location:
     message: str
 
     def to_dict(self) -> dict[str, object]:
-        return {"file": self.file, "line": self.line, "col": self.col, "message": self.message}
+        return {
+            "file": self.file,
+            "line": self.line,
+            "col": self.col,
+            "message": self.message,
+        }
 
 
 @dataclass
@@ -115,7 +132,7 @@ def run_ruff(project_path: Path) -> dict[str, FindingGroup]:
     # Resolution: the python-linters environment's own pinned ruff, run as
     # `sys.executable -m ruff` so it never falls through to PATH. In
     # dev-dependency mode that environment is the linted project's venv, so
-    # ruff==0.17.3 (pinned in python-linters' own pyproject.toml) is what
+    # ruff==0.17.5 (pinned in python-linters' own pyproject.toml) is what
     # actually runs — never a PATH ruff of another version, which lints
     # with other rules and may refuse the reference config.
     #
@@ -123,7 +140,16 @@ def run_ruff(project_path: Path) -> dict[str, FindingGroup]:
     # selector, bad config, ...). Empty stdout on exit 2 must never read
     # as "0 findings" — `run_checked` raises instead of returning in that case.
     result = run_checked(
-        [sys.executable, "-m", "ruff", "check", "--no-cache", "--output-format", "json", "."],
+        [
+            sys.executable,
+            "-m",
+            "ruff",
+            "check",
+            "--no-cache",
+            "--output-format",
+            "json",
+            ".",
+        ],
         project_path,
         "ruff",
         ok_codes=(0, 1),
@@ -147,6 +173,53 @@ def run_ruff(project_path: Path) -> dict[str, FindingGroup]:
     return _group_findings(findings())
 
 
+def run_ruff_format(project_path: Path) -> dict[str, FindingGroup]:
+    # Resolution: same as run_ruff above — `sys.executable -m ruff`, never
+    # PATH, `--no-cache` so a read-only linted project tree is never an
+    # issue.
+    #
+    # `ruff format --check` has no JSON output mode (unlike `ruff check`):
+    # `ruff format --help` lists `--output-format` only under `check`, not
+    # under `format`. Its human-readable stdout does carry one `-->
+    # path:line:col` line per unformatted file, which is parsed below
+    # instead.
+    #
+    # ruff format's exit codes: 0 all formatted, 1 some file would be
+    # reformatted, 2 tool failure (bad config, crash, ...). A failure must
+    # never read as "0 findings" — `run_checked` raises instead of
+    # returning in that case.
+    result = run_checked(
+        [sys.executable, "-m", "ruff", "format", "--check", "--no-cache", "."],
+        project_path,
+        "ruff-format",
+        ok_codes=(0, 1),
+    )
+    if not result.stdout.strip():
+        return {}
+
+    def findings() -> Iterable[_Finding]:
+        for line in result.stdout.splitlines():
+            match = _RUFF_FORMAT_LOCATION_RE.match(line)
+            if match is None:
+                continue
+            location = Location(
+                file=_relative_to(match["file"], project_path),
+                line=int(match["line"]),
+                col=int(match["col"]),
+                message="would be reformatted",
+            )
+            yield "unformatted", None, None, location
+
+    groups = _group_findings(findings())
+    # Exit 1 with nothing parsed means ruff changed its text output: fail
+    # loudly instead of reporting a clean project.
+    if result.returncode == 1 and not groups:
+        detail = f"exit 1 but no ' --> path:line:col' line parsed:\n{result.stdout}"
+        tool = "ruff-format"
+        raise ToolFailedError(tool, detail)
+    return groups
+
+
 def run_ty(project_path: Path) -> dict[str, FindingGroup]:
     # Resolution: `sys.executable -m ty` from the python-linters
     # environment, never a bare `ty` entry point (that one falls through to
@@ -226,8 +299,15 @@ def run_pymodularity(project_path: Path) -> dict[str, FindingGroup]:
     # 2 `uv` missing or an uncaught exception (docs/rules.md "JSON output").
     # A failure must never read as "0 findings".
     result = run_checked(
-        [sys.executable, "-m", "pymodularity", "check", "--output-format", "json",
-         str(project_path)],
+        [
+            sys.executable,
+            "-m",
+            "pymodularity",
+            "check",
+            "--output-format",
+            "json",
+            str(project_path),
+        ],
         project_path,
         "pymodularity",
         ok_codes=(0, 1),
@@ -259,7 +339,12 @@ def build_report(project_path: Path) -> tuple[dict[str, object], int]:
     sections: dict[str, object] = {}
     grand_total = 0
 
-    for tool, run in (("ruff", run_ruff), ("ty", run_ty), ("pymodularity", run_pymodularity)):
+    for tool, run in (
+        ("ruff", run_ruff),
+        ("ruff-format", run_ruff_format),
+        ("ty", run_ty),
+        ("pymodularity", run_pymodularity),
+    ):
         print(f"Running {tool} on {project_path} ...", file=sys.stderr)
         violations = run(project_path)
         total = sum(group.count for group in violations.values())

{python_linters-0.2.0 → python_linters-0.2.2}/src/python_linters/references/ruff.reference.toml

@@ -12,7 +12,7 @@
 #   5. flake8-type-checking — list your runtime-evaluated base classes and
 #                           decorators (pydantic, FastAPI preset)
 #
-# Last triaged against: ruff 0.17.3
+# Last triaged against: ruff 0.17.5
 # Rule names in `select`/`ignore` and in `# ruff: ignore[...]` comments need
 # `preview = true`: without it ruff rejects the config and treats name-based
 # suppression comments as inert.
@@ -20,7 +20,7 @@
 
 # Older ruff fails on the first rule name it does not know, with a cryptic
 # `Unknown rule selector`. This guard names the version instead.
-required-version = ">=0.17.3"
+required-version = ">=0.17.5"
 
 target-version = "py312"
 
@@ -94,6 +94,8 @@ select = [
 
     # ── Security ──
     "S",     # flake8-bandit — security antipatterns (hardcoded passwords, exec, …)
+    "tarfile-ignore-zeros-true",  # code-less rule: `ignore_zeros=True` reads past the
+                                  #   end-of-archive marker, so appended members get extracted too
     "EXE",   # flake8-executable — shebang correctness
 
     # ── Error handling ──
@@ -170,11 +172,11 @@ select = [
 
     # ── Preview rules, selected by name ──────────────────────────────────
     # `explicit-preview-rules = true`: a category select above turns on only its
-    # stable rules. Each preview rule below was triaged on ruff 0.17.3.
+    # stable rules. Each preview rule below was triaged on ruff 0.17.5.
     # A preview rule in a selected category that is neither listed
     # here nor covered by an `# excluded` line below is untriaged.
 
-    # Ruff-specific (25)
+    # Ruff-specific (26)
     # bugs: the code runs but does the wrong thing
     "missing-f-string-syntax",          # `"{x}"` without `f` prints the braces
     "unraw-re-pattern",                 # `"\b"` in a non-raw pattern is a backspace, not a word boundary, and nothing else warns
@@ -204,13 +206,15 @@ select = [
     "noqa-comments",
     "rule-codes-in-suppression-comments",
     "rule-codes-in-selectors",
+    "renamed-rule",                     # a config selector that only works through a rename redirect
 
-    # Pylint (18)
+    # Pylint (19)
     # bugs: runtime errors or silently lost behavior
     "dict-iter-missing-items",          # `for k, v in d` unpacks keys, not items
     "modified-iterating-set",           # RuntimeError
     "redefined-slots-in-subclass",      # makes the base class slot unreachable
     "bad-dunder-method-name",           # a misspelled dunder is never called
+    "no-method-argument",               # a method without `self`/`cls` raises TypeError when called on an instance
     "unspecified-encoding",             # `open()` without encoding uses the platform locale
     # size and nesting limits, every threshold set under [lint.pylint]
     "too-many-public-methods",
@@ -262,9 +266,11 @@ select = [
     "deprecated-abc-decorator",         # deprecated since 3.3
     "context-manager-iterator",         # @contextmanager needs Generator, Iterator lacks `throw`
 
-    # flake8-async (1): a context manager's cleanup is delayed until the
-    # generator closes, when `await` is no longer allowed
-    "yield-in-context-manager-in-async-generator",
+    # flake8-async (2)
+    "yield-in-context-manager-in-async-generator",  # the context manager's cleanup waits until
+                                                    #   the generator closes, when `await` is no longer allowed
+    "pytest-raises-exception-group",  # `pytest.RaisesGroup` checks the grouped exceptions,
+                                      #   `pytest.raises(ExceptionGroup)` only the wrapper
 
     # flake8-pytest-style (1): `pytest.warns()` without a warning fails at runtime
     "pytest-warns-without-warning",
@@ -321,9 +327,9 @@ ignore = [
     # ANN401 (typing.Any disallowed) stays ON: with basedpyright dropped
     # in favor of ty, ANN401 is the gate's only coverage for explicit
     # Any (basedpyright's reportExplicitAny): ty has no equivalent rule.
-    # missing return type on __init__, __enter__, __exit__ — always obvious
-    # from context
-    "missing-return-type-special-method",
+    # missing-return-type-special-method stays ON: ty types the target of
+    # `with X() as x` as Unknown when `__enter__` has no return type. ruff
+    # fixes `__init__ -> None` and `__str__ -> str` itself (safe fix).
     "missing-type-args",  # missing type on *args — typically pass-through,
                           #   type depends on caller
     "missing-type-kwargs",  # missing type on **kwargs — same reasoning as
@@ -339,18 +345,18 @@ ignore = [
                               #   than max_snr
 
     # ── Code style ──
-    "lambda-assignment",  # `transform = lambda x: x.strip()` is sometimes
-                          #   clearer than a named function for one-off local
-                          #   transforms
+    # lambda-assignment stays ON: a lambda cannot annotate its parameters,
+    # so ty types `strip = lambda x: x.strip()` as `(x) -> Unknown` and
+    # accepts `strip(1)`.
     "in-dict-keys",  # use `key in dict` — `key in dict.keys()` is more
                      #   explicit about intent; Python Zen says explicit >
                      #   implicit
     "superfluous-else-return",  # the else branch makes the two paths visually
                                 #   symmetric and easier to read
     "superfluous-else-raise",  # same reasoning as superfluous-else-return
-    # super() issues with dataclass(slots=True), see
-    # https://stackoverflow.com/questions/73268995
-    "super-call-with-parameters",
+    # super-call-with-parameters stays ON: zero-argument super() fails in a
+    # dataclass(slots=True) before Python 3.14, but ruff skips slots
+    # dataclasses for this rule (checked on ruff 0.17.3).
     "compare-to-empty-string",  # `s == ""` is more explicit than `not s` (the
                                 #   latter also matches None, 0, [])
 
@@ -391,11 +397,16 @@ ignore = [
                                 #   callers, so its method count is not an
                                 #   interface
     # missing return type — test functions always return None
-    "missing-return-type-undocumented-public-function",
+    "missing-return-type-public-function",
     "import-private-name",  # testing internal functions is legitimate
     "unused-async",  # async test doubles mirror the awaited signature they replace
     "float-equality-comparison",  # asserting an exactly representable result is correct
     "too-many-locals",  # an integration test sets up many real collaborators
+    "missing-type-function-argument",  # pytest fixtures: the fixture defines the type
+    "missing-return-type-private-function",  # helpers and fakes local to a test module
+    "missing-return-type-special-method",  # `__init__` / `__enter__` on test doubles
+    "import-outside-top-level",  # imports inside a test patch or isolate the import
+    "private-member-access",  # tests inspect internal state on purpose
 ]
 "test_*.py" = [
     "assert",
@@ -403,12 +414,17 @@ ignore = [
     "magic-value-comparison",
     "no-self-use",
     "too-many-public-methods",
-    "missing-return-type-undocumented-public-function",
+    "missing-return-type-public-function",
     "implicit-namespace-package",  # standalone test scripts
     "import-private-name",
     "unused-async",
     "float-equality-comparison",
     "too-many-locals",
+    "missing-type-function-argument",
+    "missing-return-type-private-function",
+    "missing-return-type-special-method",
+    "import-outside-top-level",
+    "private-member-access",
 ]
 
 # ── isort ───────────────────────────────────────────────────────────────────

{python_linters-0.2.0 → python_linters-0.2.2}/src/python_linters/references/ty.reference.toml

@@ -2,7 +2,7 @@
 # ty Reference Configuration
 # ============================================================================
 #
-# Canonical rule table for new Python projects. Every rule ty 0.0.90 knows is
+# Canonical rule table for new Python projects. Every rule ty 0.0.103 knows is
 # listed below, one line each, with no `all = "error"` base. Each line is
 # "error" or "ignore". A "warn" setting is never used, because a warning
 # does not fail a CI gate, so a green run hides it.
@@ -16,8 +16,8 @@
 #   - into `pyproject.toml` under `[tool.ty.rules]` (rename the table header,
 #     keep every line).
 #
-# Last triaged against: ty 0.0.90 (140 rules: 97 error-by-default,
-# 25 warn-by-default, 18 ignore-by-default).
+# Last triaged against: ty 0.0.103 (152 rules: 107 error-by-default,
+# 27 warn-by-default, 18 ignore-by-default).
 #
 # Re-check the copied table after every ty version bump:
 #   python-linters check-config ty <path/to/ty.toml>
@@ -51,7 +51,7 @@ redundant-condition-strict = "ignore"
 # `re.Match.group()`) goes unflagged.
 # Re-triage on each ty bump: ty is 0.0.x and its inference changes.
 unsound-assignment = "ignore"
-unsound-return-statement = "ignore"
+unsound-return = "ignore"
 unsound-yield = "ignore"
 
 # not applicable: checks classes built with `type()`, which the doctrine
@@ -80,66 +80,69 @@ truthiness-test-of-none-union = "error"
 # --- Enforced rules: on by default in ty, alphabetical ----------------------
 
 abstract-and-final-method = "error"
+abstract-class-instantiation = "error"
+abstract-method-call = "error"
 abstract-method-in-final-class = "error"
 ambiguous-protocol-member = "error"
 assert-type-unspellable-subtype = "error"
-call-abstract-method = "error"
-call-non-callable = "error"
-call-top-callable = "error"
+call-to-function-with-unknown-signature = "error"
 conflicting-declarations = "error"
 conflicting-metaclass = "error"
 cyclic-class-definition = "error"
 cyclic-type-alias-definition = "error"
-dataclass-field-order = "error"
 deprecated = "error"
 duplicate-base = "error"
 duplicate-kw-only = "error"
-empty-body = "error"
 escape-character-in-forward-annotation = "error"
 experimental-syntax = "error"
 final-on-non-method = "error"
 final-without-value = "error"
 ignore-comment-unknown-rule = "error"
-implicit-concatenated-string-type-annotation = "error"
+implicit-string-concatenation-in-annotation = "error"
+import-not-found = "error"
+incompatible-attribute-override = "error"
+incompatible-method-override = "error"
+incompatible-mutable-override = "error"
+incompatible-property-override = "error"
 inconsistent-mro = "error"
+inconsistent-overload-decorator = "error"
+inconsistent-overload-implementation = "error"
 index-out-of-bounds = "error"
 ineffective-final = "error"
 instance-layout-conflict = "error"
 invalid-argument-type = "error"
 invalid-assignment = "error"
 invalid-attribute-access = "error"
-invalid-attribute-override = "error"
 invalid-await = "error"
 invalid-base = "error"
 invalid-context-manager = "error"
 invalid-dataclass = "error"
+invalid-dataclass-field-order = "error"
 invalid-dataclass-override = "error"
 invalid-declaration = "error"
 invalid-enum-member-annotation = "error"
 invalid-exception-caught = "error"
 invalid-explicit-override = "error"
+invalid-explicit-return = "error"
 invalid-frozen-dataclass-subclass = "error"
+invalid-generator-return-type = "error"
 invalid-generic-class = "error"
 invalid-generic-enum = "error"
 invalid-ignore-comment = "error"
+invalid-implicit-return = "error"
+invalid-implicit-return-in-function-with-stub-body = "error"
 invalid-init-type-variable = "error"
-invalid-key = "error"
 invalid-legacy-type-variable = "error"
 invalid-match-pattern = "error"
 invalid-metaclass = "error"
-invalid-method-override = "error"
 invalid-module-getattr-call = "error"
-invalid-mutable-override = "error"
 invalid-named-tuple = "error"
 invalid-named-tuple-override = "error"
 invalid-newtype = "error"
-invalid-overload = "error"
 invalid-parameter-default = "error"
 invalid-paramspec = "error"
-invalid-property-type-override = "error"
 invalid-protocol = "error"
 invalid-raise = "error"
-invalid-return-type = "error"
 invalid-super-argument = "error"
 invalid-syntax-in-forward-annotation = "error"
 invalid-total-ordering = "error"
@@ -153,16 +156,24 @@ invalid-type-variable-constraints = "error"
 invalid-type-variable-default = "error"
 invalid-typed-dict-field = "error"
 invalid-typed-dict-header = "error"
+invalid-typed-dict-key = "error"
 invalid-typed-dict-statement = "error"
 invalid-yield = "error"
 isinstance-against-protocol = "error"
 isinstance-against-typed-dict = "error"
+lost-keyword-for-regular-parameter = "error"
 mismatched-type-name = "error"
+misplaced-overload-decorator = "error"
 missing-argument = "error"
+missing-attribute = "error"
+missing-overload-implementation = "error"
 missing-slot = "error"
 missing-typed-dict-key = "error"
+missing-union-attribute = "error"
 no-matching-overload = "error"
 non-callable-init-subclass = "error"
+non-literal-typed-dict-key = "error"
+not-callable = "error"
 not-iterable = "error"
 not-subscriptable = "error"
 override-of-final-method = "error"
@@ -176,7 +187,9 @@ raw-string-type-annotation = "error"
 redundant-cast = "error"
 redundant-condition = "error"
 redundant-final-classvar = "error"
+renamed-rule-in-ignore-comment = "error"
 shadowed-type-variable = "error"
+single-overload = "error"
 static-assert-error = "error"
 subclass-of-dataclass-with-order = "error"
 subclass-of-final-class = "error"
@@ -189,9 +202,8 @@ unavailable-implicit-super-arguments = "error"
 unbound-type-variable = "error"
 undefined-reveal = "error"
 unknown-argument = "error"
-unresolved-attribute = "error"
+unknown-typed-dict-constructor-key = "error"
 unresolved-global = "error"
-unresolved-import = "error"
 unresolved-reference = "error"
 unsupported-base = "error"
 unsupported-bool-conversion = "error"