@neralabs/rerail-pack-python 0.1.2 → 0.1.4

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

@@ -0,0 +1,406 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b030-except-with-non-exception-classes",
+  "revision": 2,
+  "mode": "steer",
+  "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": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "except-with-non-exception-classes",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "type-slot": {
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^(except|\\*)$"
+                  },
+                  "not": {
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "regex": "^,$"
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "except_clause"
+                  }
+                },
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "as_pattern",
+                    "matches": "type-slot"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "type-slot"
+                  }
+                }
+              ]
+            },
+            "plus": {
+              "kind": "binary_operator",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "^\\+$"
+              }
+            },
+            "core": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "parenthesized_expression"
+                  },
+                  {
+                    "kind": "comment"
+                  },
+                  {
+                    "regex": "^[(),*+:\\[\\]]$"
+                  },
+                  {
+                    "kind": "as_pattern"
+                  }
+                ]
+              }
+            },
+            "comma-elem": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "except_clause"
+                  },
+                  "any": [
+                    {
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "regex": "^,$"
+                      }
+                    },
+                    {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "^,$"
+                      }
+                    }
+                  ]
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "comma-elem"
+                  }
+                }
+              ]
+            },
+            "queued-splat": {
+              "kind": "list_splat",
+              "matches": "queued"
+            },
+            "queued-plus": {
+              "matches": "plus",
+              "all": [
+                {
+                  "matches": "queued"
+                }
+              ]
+            },
+            "elem-of-type-tuple": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "tuple",
+                    "matches": "type-slot"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "elem-of-type-tuple"
+                  }
+                }
+              ]
+            },
+            "elem-of-splat-seq": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "tuple"
+                      },
+                      {
+                        "kind": "list"
+                      }
+                    ],
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "matches": "queued-splat"
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "elem-of-splat-seq"
+                  }
+                }
+              ]
+            },
+            "value-of-queued-splat": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "matches": "queued-splat"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "value-of-queued-splat"
+                  }
+                }
+              ]
+            },
+            "side-of-queued-plus": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "matches": "queued-plus"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "side-of-queued-plus"
+                  }
+                }
+              ]
+            },
+            "elem-of-side-tuple": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "tuple",
+                    "matches": "side-of-queued-plus"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "elem-of-side-tuple"
+                  }
+                }
+              ]
+            },
+            "value-of-side-splat": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "list_splat",
+                    "matches": "side-of-queued-plus"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "value-of-side-splat"
+                  }
+                }
+              ]
+            },
+            "queued": {
+              "matches": "core",
+              "any": [
+                {
+                  "matches": "type-slot",
+                  "not": {
+                    "kind": "tuple"
+                  }
+                },
+                {
+                  "matches": "elem-of-type-tuple"
+                },
+                {
+                  "matches": "comma-elem"
+                },
+                {
+                  "matches": "elem-of-splat-seq"
+                },
+                {
+                  "matches": "plus",
+                  "all": [
+                    {
+                      "matches": "value-of-queued-splat"
+                    }
+                  ]
+                },
+                {
+                  "matches": "plus",
+                  "all": [
+                    {
+                      "matches": "side-of-queued-plus"
+                    }
+                  ]
+                },
+                {
+                  "matches": "elem-of-side-tuple"
+                },
+                {
+                  "matches": "plus",
+                  "all": [
+                    {
+                      "matches": "value-of-side-splat"
+                    }
+                  ]
+                }
+              ]
+            },
+            "flat": {
+              "matches": "core",
+              "any": [
+                {
+                  "matches": "queued",
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "list_splat"
+                      },
+                      {
+                        "matches": "plus"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "all": [
+                    {
+                      "matches": "value-of-queued-splat"
+                    }
+                  ],
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "tuple"
+                      },
+                      {
+                        "kind": "list"
+                      },
+                      {
+                        "matches": "plus"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "all": [
+                    {
+                      "matches": "side-of-queued-plus"
+                    }
+                  ],
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "tuple"
+                      },
+                      {
+                        "kind": "list_splat"
+                      },
+                      {
+                        "matches": "plus"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "all": [
+                    {
+                      "matches": "value-of-side-splat"
+                    }
+                  ],
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "list_splat"
+                      },
+                      {
+                        "matches": "plus"
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "matches": "flat",
+            "not": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute"
+                },
+                {
+                  "kind": "subscript"
+                },
+                {
+                  "kind": "call"
+                }
+              ]
+            },
+            "inside": {
+              "stopBy": "end",
+              "kind": "except_clause"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B030",
+        "message": "`except` handlers should only be exception classes or tuples of exception classes",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B030"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -3,7 +3,7 @@
   "id": "ruff-b905-zip-without-explicit-strict",
   "revision": 1,
   "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": [
       "**/*"

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

@@ -3,7 +3,7 @@
   "id": "ruff-e711-none-comparison",
   "revision": 1,
   "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": [
       "**/*"

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": [