@neralabs/rerail-pack-python 0.1.3 → 0.1.5

package/rules/ruff-e711-none-comparison.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-e711-none-comparison",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's E711 (none-comparison) with default settings: `None` compared with `==` or `!=`, reported on the `None` literal (inside any parentheses). The first operand is checked when the second is not a non-singleton constant; each later `None` when the operand before its operator is not one (Ruff's `is_constant_non_singleton`: string, bytes and number literals, and tuples of constants). Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/E711.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Use is None or is not None instead of == or != to compare with None; equality can be overridden and gives surprising results.",
   "scope": {
     "include": [
       "**/*"
@@ -12,7 +12,7 @@
   },
   "clauses": [
     {
-      "id": "none-comparison",
+      "id": "none-comparison-equal",
       "forbid": {
         "ast": {
           "language": "python",
@@ -113,7 +113,7 @@
                     {
                       "precedes": {
                         "stopBy": "neighbor",
-                        "regex": "^(==|!=)$",
+                        "regex": "^==$",
                         "precedes": {
                           "stopBy": "neighbor",
                           "not": {
@@ -127,7 +127,7 @@
                 {
                   "follows": {
                     "stopBy": "neighbor",
-                    "regex": "^(==|!=)$",
+                    "regex": "^==$",
                     "follows": {
                       "stopBy": "neighbor",
                       "not": {
@@ -185,7 +185,191 @@
       "violation": {
         "anchor": "witness.span",
         "code": "E711",
-        "message": "Comparison to `None` should be `cond is None`",
+        "message": "Use `is None` instead of `== None` for this comparison.",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E711"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "none-comparison-not-equal",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "constant": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "constant"
+                  }
+                },
+                {
+                  "kind": "tuple",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "matches": "constant"
+                          },
+                          {
+                            "regex": "^[(),]$"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "constant-non-singleton": {
+              "all": [
+                {
+                  "matches": "constant"
+                },
+                {
+                  "not": {
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            },
+            "compared-operand": {
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "comparison_operator"
+              },
+              "any": [
+                {
+                  "all": [
+                    {
+                      "not": {
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "(?s)."
+                        }
+                      }
+                    },
+                    {
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "regex": "^!=$",
+                        "precedes": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "matches": "constant-non-singleton"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^!=$",
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "matches": "constant-non-singleton"
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "operand": {
+              "any": [
+                {
+                  "matches": "compared-operand"
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "operand"
+                  }
+                }
+              ]
+            },
+            "singleton": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "none",
+            "matches": "operand"
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "E711",
+        "message": "Use `is not None` instead of `!= None` for this comparison.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-e721-type-comparison.json

@@ -3,7 +3,7 @@
   "id": "ruff-e721-type-comparison",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's E721 (type-comparison): a comparison with an `==` or `!=` operator whose operand on either side is a type (a call whose callee resolves to the builtin `type` or `builtins.type`, or a name from Ruff's builtin type and exception list that resolves to the builtin) while neither side is a dtype (`x.dtype`, or a call of a callee resolving to `numpy.dtype`), reported on the whole comparison once per offending operator (a chained comparison can report twice, as in Ruff).",
+  "description": "Use isinstance(), or is and is not, instead of == or != to compare types; equality on types misses subclasses and can be overridden.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-e722-bare-except.json

@@ -3,7 +3,7 @@
   "id": "ruff-e722-bare-except",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's E722 (bare-except) with default settings: an `except` clause that names no exception type, unless its body re-raises with a bare `raise` statement. Reported on the `except` keyword, as Ruff does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/E722.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Name the exception types in except clauses instead of a bare except, unless the handler re-raises; a bare except also catches KeyboardInterrupt and SystemExit.",
   "scope": {
     "include": [
       "**/*"
@@ -43,7 +43,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "E722",
-        "message": "Do not use bare `except`",
+        "message": "Name the exception types this bare except should catch; it also catches KeyboardInterrupt and SystemExit.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-e742-ambiguous-class-name.json

@@ -3,7 +3,7 @@
   "id": "ruff-e742-ambiguous-class-name",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's E742 (ambiguous-class-name): a class named `l`, `I` or `O`, reported on the name.",
+  "description": "Avoid naming classes l, I or O; in many fonts they are hard to tell apart from 1 and 0.",
   "scope": {
     "include": [
       "**/*"
@@ -33,7 +33,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "E742",
-        "message": "Ambiguous class name: `$NAME`",
+        "message": "Rename class `$NAME` to a descriptive name; in many fonts it is easy to confuse with 1 or 0.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-e743-ambiguous-function-name.json

@@ -3,7 +3,7 @@
   "id": "ruff-e743-ambiguous-function-name",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's E743 (ambiguous-function-name): a function named `l`, `I` or `O`, reported on the name. Includes `async def` and methods.",
+  "description": "Avoid naming functions or methods l, I or O; in many fonts they are hard to tell apart from 1 and 0.",
   "scope": {
     "include": [
       "**/*"
@@ -33,7 +33,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "E743",
-        "message": "Ambiguous function name: `$NAME`",
+        "message": "Rename function `$NAME` to a descriptive name; in many fonts it is easy to confuse with 1 or 0.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f403-undefined-local-with-import-star.json

@@ -3,7 +3,7 @@
   "id": "ruff-f403-undefined-local-with-import-star",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F403 (undefined-local-with-import-star): any `from <module> import *` whose module is not `__future__` (at any depth, whatever the relative level), reported on the whole statement.",
+  "description": "Avoid from module import * star imports; they hide where names come from and stop undefined names from being detected.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f405-undefined-local-with-import-star-usage.json

@@ -3,7 +3,7 @@
   "id": "ruff-f405-undefined-local-with-import-star-usage",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F405 (undefined-local-with-import-star-usage) on the engine's name resolution (M10a `resolves.unresolved: \"star\"`): a reference, or a string entry of a module `__all__`, that no binding in scope and no builtin resolves and that a visible star import may bind, reported on the name or the string; and such a name inside a string Ruff parses as a type definition (M11a `parse` with `annotation`, nested strings included), reported on each such name inside the string.",
+  "description": "Import names explicitly instead of relying on a star import to define them; names that may only come from a star import can't be checked.",
   "scope": {
     "include": [
       "**/*"
@@ -72,7 +72,7 @@
       "violation": {
         "anchor": "capture.NAME",
         "code": "F405",
-        "message": "`$NAME` may be undefined, or defined from star imports",
+        "message": "Import `$NAME` explicitly from its module; it may only be defined by a star import.",
         "each": "NAME",
         "suppress": {
           "noqa": {

package/rules/ruff-f406-undefined-local-with-nested-import-star-usage.json

@@ -3,7 +3,7 @@
   "id": "ruff-f406-undefined-local-with-nested-import-star-usage",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F406 (undefined-local-with-nested-import-star-usage): a `from <module> import *` outside module scope, i.e. anywhere inside a function or class body, reported on the whole statement.",
+  "description": "Don't use from module import * inside a function or class; star imports are only allowed at module level.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {
@@ -25,7 +25,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F406",
-        "message": "`from $MODULE import *` only allowed at module level",
+        "message": "Import the needed names from `$MODULE` explicitly; a star import is only allowed at module level.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f407-future-feature-not-defined.json

@@ -3,7 +3,7 @@
   "id": "ruff-f407-future-feature-not-defined",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F407 (future-feature-not-defined): a name imported from `__future__` (also through a relative `from .__future__`, matched by the module's text with `resolves.imported` and `relative: \"text\"`, as Ruff ignores the level) that is not one of CPython's future features (`is_known_future_feature` in ruff_python_parser's semantic_errors.rs), reported on the alias (`name as alias` included) or on the `*` of a star import.",
+  "description": "Import only real feature names from __future__; an unknown feature name is a syntax error.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {

package/rules/ruff-f501-percent-format-invalid-format.json

@@ -3,7 +3,7 @@
   "id": "ruff-f501-percent-format-invalid-format",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F501 (percent-format-invalid-format): a `%`-format string the parser refuses for any reason but an unsupported format character (an incomplete specifier, an unclosed mapping key, a width or precision too big). The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Fix malformed %-format strings, such as incomplete specifiers or unclosed %(key) names; they raise an error at run time.",
   "scope": {
     "include": [
       "**/*"
@@ -74,7 +74,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F501",
-        "message": "`%`-format string has invalid format string",
+        "message": "Fix this malformed %-format string, such as an incomplete specifier or an unclosed %(key) name.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f502-percent-format-expected-mapping.json

@@ -3,7 +3,7 @@
   "id": "ruff-f502-percent-format-expected-mapping",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F502 (percent-format-expected-mapping): a valid `%`-format string with a `%(key)` placeholder applied to a list, tuple or set display, a list or set comprehension or a generator. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Pass a mapping, not a list, tuple or set, to a %-format string that uses %(key) placeholders; the call fails at run time.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f503-percent-format-expected-sequence.json

@@ -3,7 +3,7 @@
   "id": "ruff-f503-percent-format-expected-sequence",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F503 (percent-format-expected-sequence): a valid `%`-format string consuming more than one positional value (placeholders without a key, and `*` widths and precisions) applied to a dict display or comprehension. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Pass a tuple, not a dict, to a %-format string with several positional placeholders; the call fails at run time.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f504-percent-format-extra-named-arguments.json

@@ -3,7 +3,7 @@
   "id": "ruff-f504-percent-format-extra-named-arguments",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F504 (percent-format-extra-named-arguments): a valid `%`-format string without positional placeholders applied to a dict display without `**` with a string-literal key no `%(key)` placeholder names. `formatArgs` reads the format string left of `%` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser), and the right operand as Ruff's strings.rs does.",
+  "description": "Remove dict keys that no %(key) placeholder in the %-format string uses; an unused key usually means a typo or a stale argument.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f505-percent-format-missing-argument.json

@@ -3,7 +3,7 @@
   "id": "ruff-f505-percent-format-missing-argument",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F505 (percent-format-missing-argument): a valid `%`-format string without positional placeholders applied to a dict display without `**`, all of whose keys are string literals, that passes no value for some `%(key)` placeholder. `formatArgs` reads the format string left of `%` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser), and the right operand as Ruff's strings.rs does.",
+  "description": "Supply a value for every %(key) placeholder in a %-format string; a missing key raises KeyError at run time.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f506-percent-format-mixed-positional-and-named.json

@@ -3,7 +3,7 @@
   "id": "ruff-f506-percent-format-mixed-positional-and-named",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F506 (percent-format-mixed-positional-and-named): a valid `%`-format string with both a `%(key)` placeholder and a positional value (a placeholder without a key, or a `*` width or precision). The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Don't mix %(key) placeholders and positional placeholders in one %-format string; Python cannot format it.",
   "scope": {
     "include": [
       "**/*"
@@ -100,7 +100,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F506",
-        "message": "`%`-format string has mixed positional and named placeholders",
+        "message": "Use only %(key) placeholders or only positional ones in this format string; Python cannot format a mix.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f507-percent-format-positional-count-mismatch.json

@@ -3,7 +3,7 @@
   "id": "ruff-f507-percent-format-positional-count-mismatch",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F507 (percent-format-positional-count-mismatch): a valid `%`-format string without `%(key)` placeholders whose positional values differ in number from a tuple display without starred items, or, with any count but one, from a right operand Ruff's ResolvedPythonType infers as one non-tuple value; with no placeholder, any right operand but a tuple display or one Ruff types as a tuple (`(1,) + (2,)`). `formatArgs` reads the format string left of `%` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser), and the right operand as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F507.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Match the number of %-format placeholders to the number of values supplied; a mismatch raises TypeError at run time.",
   "scope": {
     "include": [
       "**/*"
@@ -64,7 +64,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F507",
-        "message": "`%`-format string placeholder count differs from the substitution count",
+        "message": "Make the number of values match the placeholders in this %-format string; a mismatch raises TypeError.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f508-percent-format-star-requires-sequence.json

@@ -3,7 +3,7 @@
   "id": "ruff-f508-percent-format-star-requires-sequence",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F508 (percent-format-star-requires-sequence): a valid `%`-format string with a `*` width or precision applied to a dict display or comprehension. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Pass a tuple, not a dict, to a %-format string that uses a * width or precision; the call fails at run time.",
   "scope": {
     "include": [
       "**/*"
@@ -98,7 +98,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F508",
-        "message": "`%`-format string `*` specifier requires sequence",
+        "message": "Pass a tuple instead of a dict to this %-format string; its `*` width or precision takes positional values.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f509-percent-format-unsupported-format-character.json

@@ -3,7 +3,7 @@
   "id": "ruff-f509-percent-format-unsupported-format-character",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F509 (percent-format-unsupported-format-character): a `%`-format string the parser refuses at an unsupported conversion character. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "description": "Use only valid conversion characters in Python %-format strings; an unsupported one raises ValueError at runtime.",
   "scope": {
     "include": [
       "**/*"
@@ -72,7 +72,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F509",
-        "message": "`%`-format string has unsupported format character",
+        "message": "Replace the unsupported conversion character in this %-format string with a valid one such as `s`, `d`, `r` or `f`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f521-string-dot-format-invalid-format.json

@@ -3,7 +3,7 @@
   "id": "ruff-f521-string-dot-format-invalid-format",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F521 (string-dot-format-invalid-format): a `.format` call on a str literal the format parser refuses (unmatched braces, fields nested deeper than one level, an empty attribute or index, an unclosed `[`, a bad conversion or format spec). The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) receiving `.format`, read with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it).",
+  "description": "Keep str.format() strings well-formed, with balanced braces and valid fields and format specs; a malformed one raises ValueError at runtime.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f522-string-dot-format-extra-named-arguments.json

@@ -3,7 +3,7 @@
   "id": "ruff-f522-string-dot-format-extra-named-arguments",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F522 (string-dot-format-extra-named-arguments): a `.format` call without `**` on a valid format string, passing a keyword argument no named field (top level or nested in a spec) reads. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does.",
+  "description": "Remove keyword arguments to str.format() that no named placeholder in the string uses; they are silently ignored.",
   "scope": {
     "include": [
       "**/*"
@@ -32,7 +32,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F522",
-        "message": "`.format` call has unused named argument(s)",
+        "message": "Remove the keyword arguments that no named placeholder in this str.format() string uses.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f523-string-dot-format-extra-positional-arguments.json

@@ -3,7 +3,7 @@
   "id": "ruff-f523-string-dot-format-extra-positional-arguments",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F523 (string-dot-format-extra-positional-arguments): a `.format` call on a valid format string with a positional argument (not starred; counted by syntactic index, past a starred one too) that no automatic or numbered field reads. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F523.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Remove positional arguments to str.format() that no placeholder in the string uses; they are silently ignored.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f524-string-dot-format-missing-arguments.json

@@ -3,7 +3,7 @@
   "id": "ruff-f524-string-dot-format-missing-arguments",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F524 (string-dot-format-missing-arguments): a `.format` call without `*` or `**` on a valid format string with a field (top level or nested in a spec) whose index is past the positional arguments or whose name no keyword argument passes. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F524.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Pass an argument for every placeholder in a str.format() string; a missing one raises IndexError or KeyError at runtime.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f525-string-dot-format-mixing-automatic.json

@@ -3,7 +3,7 @@
   "id": "ruff-f525-string-dot-format-mixing-automatic",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F525 (string-dot-format-mixing-automatic): a `.format` call on a valid format string with both an automatically numbered field (`{}`) and a manually numbered one (`{0}`), nested fields in specs included. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) receiving `.format`, read with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it).",
+  "description": "Don't mix automatic and manually numbered fields in one str.format() string; Python raises ValueError at runtime.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f541-f-string-missing-placeholders.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-f541-f-string-missing-placeholders",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's F541 (f-string-missing-placeholders) with default settings: every f-string part of a string expression (an implicit concatenation counts as one expression) when no f-string part of that expression has a replacement field. `{{`/`}}` escapes are not placeholders; nested f-strings inside a replacement field or format spec are their own expressions.",
+  "description": "Remove the f prefix from Python f-strings that have no placeholders; it suggests interpolation that never happens.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {
@@ -38,7 +38,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F541",
-        "message": "f-string without any placeholders",
+        "message": "Remove the `f` prefix and unescape doubled braces to keep this string's runtime value unchanged.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f601-multi-value-repeated-key-literal.json

@@ -3,7 +3,7 @@
   "id": "ruff-f601-multi-value-repeated-key-literal",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F601 (multi-value-repeated-key-literal) with default settings: a literal dictionary key (string, bytes, number, boolean, None, Ellipsis, tuple, f-string, signed number, real +/- imaginary; Ruff's is_literal_key) equal to an earlier key of the same dict display, reported on each repeat (parentheses are transparent). Equality is Ruff's HashableExpr (`compare` `text: \"structure-hash\"`): numbers fold by value (`1 == 1.0 == True`, `1 + 0j == 1`), strings by decoded value, tuples of constants element by element, anything else structurally as ComparableExpr (names without NFKC normalization). Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F601.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Avoid repeating a literal key (or an equal one, like 1 and 1.0) in a Python dict literal; the later value silently overwrites the earlier one.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f602-multi-value-repeated-key-variable.json

@@ -3,7 +3,7 @@
   "id": "ruff-f602-multi-value-repeated-key-variable",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F602 (multi-value-repeated-key-variable) with default settings: a dictionary key that is a bare name equal to an earlier key of the same dict display, reported on each repeat (parentheses transparent).",
+  "description": "Avoid repeating the same variable as a key in a Python dict literal; the later value silently overwrites the earlier one.",
   "scope": {
     "include": [
       "**/*"
@@ -109,7 +109,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F602",
-        "message": "Dictionary key `$KEY` repeated",
+        "message": "Remove or merge the repeated key `$KEY` in this dict; the later value silently overwrites the earlier one.",
         "suppress": {
           "noqa": {
             "codes": [