@neralabs/rerail-pack-python 0.1.3 → 0.1.5

package/rules/ruff-async105-trio-sync-call.json

@@ -3,7 +3,7 @@
  "id": "ruff-async105-trio-sync-call",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC105 (trio-sync-call): a call to one of trio's async functions (Ruff's MethodName::is_async list) that is not the operand of an `await` (parentheses ignored), in any context. Reported on the call. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Await calls to trio's async functions such as trio.sleep; without await the call only creates a coroutine that never runs.",
  "scope": {
   "include": [
    "**/*"

package/rules/ruff-async115-async-zero-sleep.json

@@ -3,7 +3,7 @@
  "id": "ruff-async115-async-zero-sleep",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC115 (async-zero-sleep): a call to `trio.sleep` or `anyio.sleep` with exactly one argument, an int literal whose value is zero (any radix; parentheses allowed) as `seconds=` (trio), `delay=` (anyio) or the first positional argument, in any context, reported on the call. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Use lowlevel.checkpoint() instead of sleep(0) in trio and anyio code; it states the intent of yielding to the scheduler.",
  "scope": {
   "include": [
    "**/*"

package/rules/ruff-async116-long-sleep-not-forever.json

@@ -3,7 +3,7 @@
  "id": "ruff-async116-long-sleep-not-forever",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC116 (long-sleep-not-forever): a call to `trio.sleep` or `anyio.sleep` with exactly one argument, an int or float literal (any spelling; not complex, not signed; parentheses allowed) whose value is greater than 86400 as `seconds=` (trio), `delay=` (anyio) or the first positional argument, in any context, reported on the call. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Use sleep_forever() instead of trio or anyio sleep calls longer than 24 hours; a sleep that long is almost always meant to never end.",
  "scope": {
   "include": [
    "**/*"

package/rules/ruff-async210-blocking-http-call-in-async-function.json

@@ -1,9 +1,9 @@
 {
  "format": "rerail.policy/v1",
  "id": "ruff-async210-blocking-http-call-in-async-function",
- "revision": 1,
+ "revision": 2,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC210 (blocking-http-call-in-async-function): a call to `urllib.request.urlopen`, `urllib3.request` or an `httpx`/`requests` module-level HTTP method inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't make blocking HTTP calls with requests, httpx, urllib or urllib3 inside async functions; they stall the event loop.",
  "scope": {
   "include": [
    "**/*"
@@ -147,7 +147,7 @@
    "violation": {
     "anchor": "witness.span",
     "code": "ASYNC210",
-    "message": "Async functions should not call blocking HTTP methods",
+    "message": "Use an existing async client, or `await asyncio.to_thread(helper, ...)` for the request and response handling; preserve the API and options.",
     "suppress": {
       "noqa": {
         "codes": [

package/rules/ruff-async221-run-process-in-async-function.json

@@ -3,7 +3,7 @@
  "id": "ruff-async221-run-process-in-async-function",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC221 (run-process-in-async-function): a call to `os.system`, `os.posix_spawn[p]`, `subprocess.run`/`call`/`check_call`/`check_output`/`getoutput`/`getstatusoutput`, or an `os.spawn*` function whose mode (Ruff's find_argument_value(\"mode\", 0): `arguments` in syntactic mode) is absent or `os.P_WAIT` (directly, or through a name whose value, read as find_assigned_value's lookup_symbol does (`resolves.binding` with `stopAtGlobal`), is `os.P_WAIT`) inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't run processes with subprocess.run, os.system or other blocking process calls inside async functions; they block the event loop until the process exits.",
  "scope": {
   "include": [
    "**/*"

package/rules/ruff-async222-wait-for-process-in-async-function.json

@@ -1,9 +1,9 @@
 {
  "format": "rerail.policy/v1",
  "id": "ruff-async222-wait-for-process-in-async-function",
- "revision": 1,
+ "revision": 2,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC222 (wait-for-process-in-async-function): a call to `os.wait`, `os.wait3`, `os.wait4`, `os.waitid` or `os.waitpid` inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't call os.wait, os.waitpid or the other blocking os.wait functions inside async functions; they block the event loop.",
  "scope": {
   "include": [
    "**/*"
@@ -130,7 +130,7 @@
    "violation": {
     "anchor": "witness.span",
     "code": "ASYNC222",
-    "message": "Async functions should not wait on processes with blocking methods",
+    "message": "Offload the wait with `await asyncio.to_thread(wait_fn, ...)`; preserve arguments and status. Await `proc.wait()` only for an async process.",
     "suppress": {
       "noqa": {
         "codes": [

package/rules/ruff-async230-blocking-open-call-in-async-function.json

@@ -3,7 +3,7 @@
  "id": "ruff-async230-blocking-open-call-in-async-function",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC230 (blocking-open-call-in-async-function): a call to the builtin `open` (`builtins.open`, `io.open`, `io.open_code`), or `.open()` on a `pathlib.Path(...)` call or on a name whose binding holds one (Ruff's find_binding_value through `resolves.binding`: a plain name assignment, annotated assignment or walrus value, an unpacked name's element of a tuple or list display, or a `with` item's context expression; and, as Ruff's match_value, an unpacked name paired with a display element by index where the engine gives no value: a set display, unequal arities, a position after a starred value), inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't open files with open(), io.open or Path.open() inside async functions; use an async file API so file I/O doesn't block the event loop.",
  "scope": {
   "include": [
    "**/*"
@@ -325,7 +325,7 @@
    "violation": {
     "anchor": "witness.span",
     "code": "ASYNC230",
-    "message": "Async functions should not open files with blocking methods like `open`",
+    "message": "Open this file with an async file API, such as `anyio.open_file()`, `trio.open_file()` or `aiofiles.open()`.",
     "suppress": {
       "noqa": {
         "codes": [

package/rules/ruff-async250-blocking-input-in-async-function.json

@@ -3,7 +3,7 @@
  "id": "ruff-async250-blocking-input-in-async-function",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC250 (blocking-input-in-async-function): a call to the builtin `input` (the unshadowed name, or `builtins.input`) inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't call input() inside async functions; it blocks the event loop while waiting for the user.",
  "scope": {
   "include": [
    "**/*"
@@ -129,7 +129,7 @@
    "violation": {
     "anchor": "witness.span",
     "code": "ASYNC250",
-    "message": "Blocking call to `input()` in async context",
+    "message": "Read input in a worker thread, such as `await asyncio.to_thread(input)`, instead of calling `input()` directly.",
     "suppress": {
       "noqa": {
         "codes": [

package/rules/ruff-async251-blocking-sleep-in-async-function.json

@@ -3,7 +3,7 @@
  "id": "ruff-async251-blocking-sleep-in-async-function",
  "revision": 1,
  "mode": "steer",
- "description": "Port of Ruff's ASYNC251 (blocking-sleep-in-async-function): a call to `time.sleep` inside an `async def` body whose function is the nearest enclosing function, lambda body or class, reported on the callee. Names resolve as in Ruff's resolve_qualified_name, through the engine's `resolves` (M7).",
+ "description": "Don't call time.sleep() inside async functions; await the async library's sleep so other tasks keep running.",
  "scope": {
   "include": [
    "**/*"

package/rules/ruff-b002-unary-prefix-increment-decrement.json

@@ -3,7 +3,7 @@
   "id": "ruff-b002-unary-prefix-increment-decrement",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B002 (unary-prefix-increment-decrement): a unary `+` whose operand is a unary `+`, or a unary `-` whose operand is a unary `-` (parentheses around the operand are transparent, as in Ruff's AST). Reported on the outer unary expression.",
+  "description": "Don't write a doubled plus or minus prefix to increment or decrement a value; Python has no such operators, so the value is left unchanged.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {
@@ -26,7 +26,7 @@
           }
         }
       },
-      "violation": { "anchor": "witness.span", "code": "B002", "message": "Python does not support the unary prefix increment operator (`++`)", "suppress": { "noqa": { "codes": ["B002"] } } }
+      "violation": { "anchor": "witness.span", "code": "B002", "message": "Replace this `++` prefix with `+= 1`; Python reads `++x` as `x`, so nothing is incremented.", "suppress": { "noqa": { "codes": ["B002"] } } }
     },
     {
       "id": "unary-prefix-decrement",
@@ -48,7 +48,7 @@
           }
         }
       },
-      "violation": { "anchor": "witness.span", "code": "B002", "message": "Python does not support the unary prefix decrement operator (`--`)", "suppress": { "noqa": { "codes": ["B002"] } } }
+      "violation": { "anchor": "witness.span", "code": "B002", "message": "Replace this `--` prefix with `-= 1`; Python reads `--x` as `x`, so nothing is decremented.", "suppress": { "noqa": { "codes": ["B002"] } } }
     }
   ]
 }

package/rules/ruff-b003-assignment-to-os-environ.json

@@ -3,7 +3,7 @@
   "id": "ruff-b003-assignment-to-os-environ",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B003 (assignment-to-os-environ): a plain assignment statement with exactly one target, that target being the attribute `os.environ` (the name `os`, not resolved; parentheses around the target are transparent). Chained assignments (several targets), annotated and augmented assignments are not checked, as in Ruff. Reported on the attribute.",
+  "description": "Don't assign a new value to os.environ; it doesn't change the real process environment, so update or clear the existing mapping instead.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {
@@ -48,7 +48,7 @@
           }
         }
       },
-      "violation": { "anchor": "witness.span", "code": "B003", "message": "Assigning to `os.environ` doesn't clear the environment", "suppress": { "noqa": { "codes": ["B003"] } } }
+      "violation": { "anchor": "witness.span", "code": "B003", "message": "Update `os.environ` in place with `.clear()` and `.update()` instead of assigning a new mapping to it.", "suppress": { "noqa": { "codes": ["B003"] } } }
     }
   ]
 }

package/rules/ruff-b004-unreliable-callable-check.json

@@ -3,7 +3,7 @@
   "id": "ruff-b004-unreliable-callable-check",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B004 (unreliable-callable-check): `hasattr(x, \"__call__\")` with exactly two positional arguments, or `getattr(x, \"__call__\")` / `getattr(x, \"__call__\", default)` with two or three, no keyword arguments, the second argument a str literal (not bytes, an f- or t-string; parentheses transparent) whose value is `__call__` (escapes decoded, implicit concatenations joined). The callee (parentheses transparent) resolves to the builtin `hasattr`/`getattr` (Ruff's `resolve_builtin_symbol`, via `resolves`): the unshadowed name, or that attribute of the `builtins` module through the file's imports. Reported on the call.",
+  "description": "Use callable() instead of checking hasattr() or getattr() for __call__; the attribute check gives wrong answers for some objects.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b005-strip-with-multi-characters.json

@@ -3,7 +3,7 @@
   "id": "ruff-b005-strip-with-multi-characters",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B005 (strip-with-multi-characters): `.strip`/`.lstrip`/`.rstrip` called with exactly one positional argument that is a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value repeats a character, tested with a backreference (`(.).*\\1`). Reported on the call.",
+  "description": "Avoid strip, lstrip or rstrip with a multi-character string that repeats a character; the argument is a set of characters, not a substring to remove.",
   "scope": {
     "include": [
       "**/*"
@@ -117,7 +117,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B005",
-        "message": "Using `.strip()` with multi-character strings is misleading",
+        "message": "List each character once in this strip argument, or use `removeprefix()`/`removesuffix()` to remove a substring.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b007-unused-loop-control-variable.json

@@ -3,7 +3,7 @@
   "id": "ruff-b007-unused-loop-control-variable",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B007 (unused-loop-control-variable) with the default `dummy-variable-rgx`: a name bound by a `for` loop's target (itself, or inside tuple/list/starred targets) that does not match `^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$` and never occurs as a name expression in the loop body (the `else` clause does not count; attribute members, keyword-argument names, def/class names, parameters, import and global/nonlocal names and except-handler names are not name expressions). The message says `may not be used` when the body calls `locals`/`globals`/`vars`/`exec`/`eval` (by spelling; Ruff checks they are builtins). Match-statement capture, keyword-pattern, star and `as` names are not name expressions either. Reported on the target name.",
+  "description": "Rename for-loop variables the loop body never uses to start with an underscore; it shows the value is deliberately ignored.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b009-get-attr-with-constant.json

@@ -3,7 +3,7 @@
   "id": "ruff-b009-get-attr-with-constant",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B009 (getattr-with-constant): `getattr(obj, \"name\")` with exactly two positional arguments and no keyword arguments, `obj` not starred, the second a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value is a Python identifier (Unicode XID, not a keyword) and not a mangled private name (`__x` without a trailing `__`). The callee (parentheses transparent) resolves to the builtin `getattr` (Ruff's `match_builtin_expr`): the unshadowed name, or `getattr` of the `builtins` module through the file's imports. Reported on the call.",
+  "description": "Use plain attribute access instead of getattr() with a constant attribute name; it is no safer and harder to read.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b010-set-attr-with-constant.json

@@ -3,7 +3,7 @@
   "id": "ruff-b010-set-attr-with-constant",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B010 (set-attr-with-constant): `setattr(obj, \"name\", value)` used as an expression statement, with exactly three positional arguments and no keyword arguments, `obj` not starred, the name a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value is a Python identifier (Unicode XID, not a keyword), not `__debug__` and not a mangled private name. The callee (parentheses transparent) resolves to the builtin `setattr` (Ruff's `match_builtin_expr`): the unshadowed name, or `setattr` of the `builtins` module through the file's imports. Reported on the call.",
+  "description": "Use plain attribute assignment instead of setattr() with a constant attribute name; it is no safer and harder to read.",
   "scope": {
     "include": [
       "**/*"
@@ -205,7 +205,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B010",
-        "message": "Do not call `setattr` with a constant attribute value. It is not any safer than normal property access.",
+        "message": "Replace this `setattr` call with a plain assignment, such as `obj.name = value`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b011-assert-false.json

@@ -3,7 +3,7 @@
   "id": "ruff-b011-assert-false",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B011 (assert-false): an `assert` statement whose test is the literal `False` (Ruff's `is_const_false`; parentheses transparent), reported on the literal. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/B011.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Raise AssertionError instead of assert False; assertions are stripped when Python runs with optimizations enabled.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b013-redundant-tuple-in-exception-handler.json

@@ -3,7 +3,7 @@
   "id": "ruff-b013-redundant-tuple-in-exception-handler",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B013 (redundant-tuple-in-exception-handler): the type of an `except` (or `except*`) handler is a parenthesized tuple with exactly one element that is not starred. Parentheses around the tuple are transparent, and an `as` name does not matter. Reported on the tuple.",
+  "description": "Remove the one-element tuple around a single exception type in an except clause; the parentheses and comma are redundant.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b014-duplicate-handler-exception.json

@@ -3,7 +3,7 @@
   "id": "ruff-b014-duplicate-handler-exception",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B014 (duplicate-handler-exception): the type of an `except` (or `except*`) handler is a tuple in which the same dotted name (a name or an attribute chain of names, Ruff's `UnqualifiedName`) occurs more than once (parentheses around an element are transparent). Reported once on the tuple, whatever the number of duplicates.",
+  "description": "Remove duplicate exception types from an except clause's tuple; naming one twice adds nothing.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b016-raise-literal.json

@@ -3,7 +3,7 @@
   "id": "ruff-b016-raise-literal",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B016 (raise-literal): the exception of a `raise` statement is a literal (Ruff's `is_literal_expr`: string, bytes, number, `True`/`False`, `None`, `...`; not an f-string or t-string, including an implicit concatenation with one; parentheses transparent). Reported on the literal.",
+  "description": "Raise an exception instance instead of a literal like a string or number; raising a literal fails with a TypeError.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {

package/rules/ruff-b020-loop-variable-overrides-iterator.json

@@ -3,7 +3,7 @@
   "id": "ruff-b020-loop-variable-overrides-iterator",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B020 (loop-variable-overrides-iterator): a name in a `for` loop's target that also occurs as a name in its iterable, where comprehensions in the iterable contribute only the iterables of their `for` clauses and lambdas the children of their body (Ruff's `NameFinder` walks the body's children, so `lambda: x` adds nothing). A name that is a (non-variadic) parameter of a lambda in the iterable is exempt unless it occurs again after that lambda, as Ruff's walk removes it and a later occurrence adds it back. Reported on each such target name (Ruff reports only the last occurrence of a name repeated in the target).",
+  "description": "Don't name a for-loop variable after a name used in the loop's iterable; the loop overwrites the original value.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b021-f-string-docstring.json

@@ -3,7 +3,7 @@
   "id": "ruff-b021-f-string-docstring",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B021 (f-string-docstring): the first statement of a module, function or class body is an expression statement whose value is an f-string (an `f`-prefixed literal, or an implicit concatenation containing one; parentheses transparent). Comments before it are not statements. Reported on the statement.",
+  "description": "Use a plain string literal, not an f-string, for docstrings; Python doesn't treat an f-string as a docstring.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {

package/rules/ruff-b022-useless-contextlib-suppress.json

@@ -3,7 +3,7 @@
   "id": "ruff-b022-useless-contextlib-suppress",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B022 (useless-contextlib-suppress): a call to `contextlib.suppress` with no positional arguments, reported on the call. The callee (parentheses transparent) resolves to `contextlib.suppress` with `resolves` (imports and shadowing as Ruff's semantic model sees them).",
+  "description": "Pass at least one exception type to contextlib.suppress(); with none it suppresses nothing.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b023-function-uses-loop-variable.json

@@ -3,7 +3,7 @@
   "id": "ruff-b023-function-uses-loop-variable",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B023 (function-uses-loop-variable): a name loaded in the body of a function or lambda defined inside a loop (for, while, or comprehension), when the function neither takes it as a parameter nor stores it anywhere in its body, and the loop assigns it (assignment, augmented or annotated assignment, for or comprehension target; not inside nested functions or lambdas). The function is the first def or unsafe lambda on the way down from the loop; a lambda is safe when it is returned directly, called immediately, a positional argument of `filter`/`reduce`/`map`/`functools.reduce`, or the value of a `key=` keyword. Reported on the name.",
+  "description": "Pass loop variables into functions and lambdas defined inside a loop as arguments or defaults; otherwise they all see the variable's last value.",
   "scope": {
     "include": [
       "**/*"
@@ -546,7 +546,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B023",
-        "message": "Function definition does not bind loop variable `$N`",
+        "message": "Bind `$N` as a default argument, such as `$N=$N`, so the function keeps this iteration's value.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b025-duplicate-try-block-exception.json

@@ -3,7 +3,7 @@
   "id": "ruff-b025-duplicate-try-block-exception",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B025 (duplicate-try-block-exception): an exception name (a name or dotted attribute chain) in an `except`/`except*` clause, as the type or a direct element of a tuple type, that an earlier handler of the same `try` already names; within one tuple only its first occurrence counts. Names compare structurally. Reported on the repeated name.",
+  "description": "Remove exception types repeated across handlers of the same try block; only the first handler that names one can ever run.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b026-star-arg-unpacking-after-keyword-arg.json

@@ -3,7 +3,7 @@
   "id": "ruff-b026-star-arg-unpacking-after-keyword-arg",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B026 (star-arg-unpacking-after-keyword-arg): a `*` unpacking argument of a call that comes after the call's first keyword argument (`name=value` or `**mapping`). Reported on the starred argument.",
+  "description": "Put star-argument unpacking before keyword arguments in calls; placing it after is legal but misleading about argument order.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b028-no-explicit-stacklevel.json

@@ -3,7 +3,7 @@
   "id": "ruff-b028-no-explicit-stacklevel",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B028 (no-explicit-stacklevel): a call to `warnings.warn` with no `stacklevel` (keyword or third positional argument: find_argument_value, through `arguments` in syntactic mode), no non-empty `skip_file_prefixes`, and no `*`/`**` unpacking. The callee resolves with `resolves` (imports and shadowing as Ruff's semantic model sees them). Reported on the callee, inside any parentheses. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/B028.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Pass an explicit stacklevel to warnings.warn(); without it the warning points at the warn call instead of the caller who triggered it.",
   "scope": {
     "include": [
       "**/*"
@@ -163,7 +163,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B028",
-        "message": "No explicit `stacklevel` keyword argument found",
+        "message": "Pass stacklevel= to this warnings.warn() call, usually 2, so the warning points at the caller.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b029-except-with-empty-tuple.json

@@ -3,7 +3,7 @@
   "id": "ruff-b029-except-with-empty-tuple",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B029 (except-with-empty-tuple): an `except`/`except*` clause whose type is the empty tuple `()` (inside any parentheses, with or without `as`). Reported on the whole clause.",
+  "description": "Don't write an except clause with an empty tuple as its type; it catches nothing, so name the exceptions to handle.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b030-except-with-non-exception-classes.json

@@ -3,7 +3,7 @@
   "id": "ruff-b030-except-with-non-exception-classes",
   "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's B030 (except-with-non-exception-classes): flattens an `except`/`except*` type as Ruff's `flatten_iterables` does (a top-level tuple's elements; `*` unpacking of tuples and lists; both sides of `+`, splicing tuple sides and unpacking starred sides) and reports each resulting expression that is not a name, attribute, subscript or call. Parentheses and an `as` binding (`except E as e`, tree-sitter's as_pattern) are transparent.",
+  "description": "Use only exception classes, or tuples of them, in except clauses; other values such as literals or expressions are not valid exception types.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b032-unintentional-type-annotation.json

@@ -3,7 +3,7 @@
   "id": "ruff-b032-unintentional-type-annotation",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B032 (unintentional-type-annotation): an annotated statement without a value whose target is a subscript of a name (`d[k]: v`) or an attribute of a name other than `self` (`o.a: v`), inside any parentheses (tree-sitter reads a parenthesized target as a one-element `tuple_pattern`). Reported on the statement.",
+  "description": "Use = instead of : when setting a subscript or another object's attribute without a value; a colon there makes a type annotation that assigns nothing.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b033-duplicate-value.json

@@ -3,7 +3,7 @@
   "id": "ruff-b033-duplicate-value",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B033 (duplicate-value): a literal element of a set display (string, bytes, number, boolean, `None`, `...`, not an f- or t-string; parentheses are transparent) equal to an earlier literal element. Equality is Ruff's HashableExpr (`compare` `text: \"structure-hash\"`): numbers fold by value (`True == 1 == 1.0 == 0x1`), strings by decoded value (`'a' == \"\\x61\"`, implicit concatenation joined), and an int of 2**64 or more by its token.",
+  "description": "Remove duplicate literal values from Python set literals; the repeat is dropped silently and usually hides a typo, and values like True, 1 and 1.0 count as the same.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b034-re-sub-positional-args.json

@@ -3,7 +3,7 @@
   "id": "ruff-b034-re-sub-positional-args",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B034 (re-sub-positional-args): a call to `re.sub` or `re.subn` with more than three positional arguments, or to `re.split` with more than two (starred arguments count). The callee resolves with `resolves` (imports and shadowing as Ruff's semantic model sees them). Reported on the call.",
+  "description": "Pass count, maxsplit and flags as keyword arguments to re.sub(), re.subn() and re.split(); their positional order is easy to get wrong.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-b039-mutable-contextvar-default.json

@@ -3,7 +3,7 @@
   "id": "ruff-b039-mutable-contextvar-default",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B039 (mutable-contextvar-default): the `default=` of a `contextvars.ContextVar(...)` call (the callee may be subscripted) is a list, dict or set display or comprehension, or a call to anything other than a function Ruff knows returns an immutable value (`is_immutable_return_type`: `datetime`, `decimal`, `fractions`, `operator`, `pathlib.Path`, `types.MappingProxyType`, `re.compile`, immutable builtins, and Ruff's option `flake8-bugbear.extend-immutable-calls`). Names resolve with `resolves` (imports, and builtins only when unshadowed). Reported on the default, inside any parentheses.",
+  "description": "Don't give a ContextVar a mutable default such as a list, dict or set; the one default object is shared across every context.",
   "scope": {
     "include": [
       "**/*"
@@ -267,7 +267,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B039",
-        "message": "Do not use mutable data structures for `ContextVar` defaults",
+        "message": "Default this ContextVar to None and set the mutable value with .set(); a mutable default is shared by every context.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b904-raise-without-from-inside-except.json

@@ -3,7 +3,7 @@
   "id": "ruff-b904-raise-without-from-inside-except",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's B904 (raise-without-from-inside-except): a `raise X` without `from` in an `except`/`except*` body, reached only through `if`/`elif`/`else`, `with`, `for` and `while` bodies (not their `else`) and `match` cases; nested `try`, `def` and `class` are not entered. `raise name` re-raising the handler's own `as` name is exempt. Reported on the raise statement.",
+  "description": "Use raise ... from err (or from None) when raising a new exception inside an except block; it keeps the cause chain clear instead of looking like a bug in the handler.",
   "scope": {
     "include": [
       "**/*.py",
@@ -180,7 +180,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B904",
-        "message": "Within an `except` clause, raise exceptions with `raise ... from err` or `raise ... from None` to distinguish them from errors in exception handling",
+        "message": "Raise this exception with `from err` or `from None` so the cause chain is clear.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-b905-zip-without-explicit-strict.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-b905-zip-without-explicit-strict",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's B905 (zip-without-explicit-strict), from target version 3.10 (`when`; `expression.rs:792`): a call to builtin `zip` (bare `zip`, or `zip` from `builtins`) with no `strict=` keyword (find_keyword, through `arguments` in syntactic mode), at least two positional arguments or a `*` argument, and no infinite iterator argument (`itertools.cycle`/`count`, `repeat` without a finite `times`). `zip` and the itertools names resolve with `resolves`, so a shadowed `zip` is not reported. Reported on the call. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/B905.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Pass strict= explicitly to zip() over two or more iterables on Python 3.10+; otherwise mismatched lengths are truncated silently.",
   "scope": {
     "include": [
       "**/*"
@@ -415,7 +415,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "B905",
-        "message": "`zip()` without an explicit `strict=` parameter",
+        "message": "Pass `strict=` explicitly: `strict=True` when lengths must match, `strict=False` when truncation is intended.",
         "suppress": {
           "noqa": {
             "codes": [