@neralabs/rerail-pack-python 0.1.2 → 0.1.4

package/rules/ruff-ret502-implicit-return-value.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret502-implicit-return-value",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET502 (implicit-return-value): a bare `return` in a function that also has a `return` with a value other than `None` (nested functions and classes are separate; generators and functions whose body is a lone `return` are skipped), reported on the `return`.",
+  "description": "Use return None instead of a bare return in Python functions that also return a value; make the None result explicit.",
   "scope": {
     "include": [
       "**/*"
@@ -149,7 +149,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "RET502",
-        "message": "Do not implicitly `return None` in function able to return non-`None` value",
+        "message": "Write `return None` instead of a bare `return`, since this function returns a value elsewhere.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-ret505-superfluous-else-return.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret505-superfluous-else-return",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET505 (superfluous-else-return): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `return` statement and no earlier direct raise/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that returns, and dedent its code; the branch already leaves the function.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret506-superfluous-else-raise.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret506-superfluous-else-raise",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET506 (superfluous-else-raise): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `raise` statement and no earlier direct return/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that raises, and dedent its code; the branch already leaves the function.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret507-superfluous-else-continue.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret507-superfluous-else-continue",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET507 (superfluous-else-continue): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `continue` statement and no earlier direct return/raise/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that continues the loop, and dedent its code; the branch already skips ahead.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret508-superfluous-else-break.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret508-superfluous-else-break",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET508 (superfluous-else-break): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `break` statement and no earlier direct return/raise/continue statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that breaks out of the loop, and dedent its code; the branch already exits the loop.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim101-duplicate-isinstance-call.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim101-duplicate-isinstance-call",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM101 (duplicate-isinstance-call): two adjacent operands of one `or` chain that are calls of the builtin `isinstance(T, C)` (exactly two positional arguments, no keywords) with equal targets (Ruff's ComparableExpr, `text: \"structure\"`; names without NFKC normalization), reported on the whole `or` chain once per run of adjacent such calls with equal targets. A parenthesized `or` is its own chain, as in Ruff's AST. `isinstance` must resolve to the builtin (`match_builtin_expr`: the unshadowed name, or `builtins.isinstance` through an import).",
+  "description": "Merge isinstance() checks on the same object joined by or into one call with a tuple of types.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim107-return-in-try-except-finally.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim107-return-in-try-except-finally",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM107 (return-in-try-except-finally): the first top-level `return` of a `finally` body when the `try` body or an `except` handler body has a top-level `return`.",
+  "description": "Don't return from a finally block when the try or except also returns; the finally return silently overrides theirs.",
   "scope": {
     "include": [
       "**/*"
@@ -68,7 +68,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM107",
-        "message": "Don't use `return` in `try`-`except` and `finally`",
+        "message": "Remove the `return` from the `finally` block; it silently overrides the `return` in `try` or `except`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim109-compare-with-tuple.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim109-compare-with-tuple",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM109 (compare-with-tuple): an `or` chain with two or more operands `N == name` (one `==`, both sides names) for the same `N`, anywhere in the chain; not reported when a comment lies inside the chain or follows it on its last line with only white space between (Ruff's has_comments). Reported on the whole `or` chain, once per such name.",
+  "description": "Use a membership test against a tuple instead of several or-chained equality checks of the same variable.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim112-uncapitalized-environment-variables.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim112-uncapitalized-environment-variables",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM112 (uncapitalized-environment-variables): a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value has an ASCII lowercase letter, other than `https_proxy`/`http_proxy`/`no_proxy`, used as `os.environ[...]` or as the first argument of a call resolving to `os.environ.get`/`os.getenv`, after Ruff's traversal has visited an absolute import of `os` (M10a `resolves.seenBefore`). Reported on the string.",
+  "description": "Use uppercase names when reading environment variables through os.environ or os.getenv; the lowercase proxy variables are exempt.",
   "scope": {
     "include": [
       "**/*"
@@ -154,7 +154,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM112",
-        "message": "Use capitalized environment variable",
+        "message": "Write this environment variable name in uppercase, and set the variable under that name wherever it is defined.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim113-enumerate-for-loop.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim113-enumerate-for-loop",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM113 (enumerate-for-loop): `N += 1` as a top-level statement of a non-async `for` body without `continue`, where the binding `N` reads (`resolves.binding`) is a name assignment of `0` (plain, annotated, or an unpacked element of a display, paired by index as Ruff's match_value where the engine gives no value) whose parent statement is the loop's, `N` is bound only once inside the loop (`binds` with `bindings` within the loop: deletions and comprehension walruses count, comprehension targets, nested functions' locals and keyword arguments do not), and no load of `N` outside the loop in its scope, at or after the initial assignment, reads the initial binding (whose references Ruff's rebinding inherits) or a binding inside the loop. The loop and the initial assignment are found again by node identity (`compare` with `text: \"node\"`), so identical loops in one scope stay apart.",
+  "description": "Use enumerate() instead of a counter that starts at 0 and is incremented by hand in each pass of a for loop.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim208-double-negation.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim208-double-negation",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM208 (double-negation): `not` applied to another `not` expression, through any parentheses, reported on the outer `not` expression (each outer `not` of a longer chain).",
+  "description": "Remove double negation with not not; use the value itself, or bool() if you need a real boolean.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim210-if-expr-with-true-false.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim210-if-expr-with-true-false",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM210 (if-expr-with-true-false): a conditional expression whose body is the literal `True` and whose `else` arm is `False` (through any parentheses), reported on the whole expression. Ruff's message and fix differ when the test is a comparison or `bool` is shadowed; what is flagged does not.",
+  "description": "Use bool() on the condition instead of a conditional expression that yields True when it holds and False otherwise.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim211-if-expr-with-false-true.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim211-if-expr-with-false-true",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM211 (if-expr-with-false-true): a conditional expression whose body is the literal `False` and whose `else` arm is `True` (through any parentheses), reported on the whole expression.",
+  "description": "Use not on the condition instead of a conditional expression that yields False when it holds and True otherwise.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim212-if-expr-with-twisted-arms.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim212-if-expr-with-twisted-arms",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM212 (if-expr-with-twisted-arms): `B if not A else A` where the negated test operand and the `else` arm are the same plain name (through any parentheses), reported on the whole expression.",
+  "description": "Swap the arms of a conditional expression that tests not x and falls back to x, so the test reads x without the negation.",
   "scope": {
     "include": [
       "**/*"
@@ -81,7 +81,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM212",
-        "message": "Use `$A if $A else ...` instead of `... if not $A else $A`",
+        "message": "Swap the arms to read `$A if $A else ...`, dropping the `not` from `... if not $A else $A`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim300-yoda-conditions.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim300-yoda-conditions",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM300 (yoda-conditions): a comparison with one `==`, `!=`, `<`, `<=`, `>` or `>=` whose left operand is more constant-like than its right, on Ruff's three levels (`ConstantLikelihood`, flake8_simplify/rules/yoda_conditions.rs:76-136): literals (not f- or t-strings) are definite; a name or attribute whose name is cased uppercase is probable; tuples, lists and dicts (keys and values, `**` values), binary operations and unary `+`/`-`/`~` take the least of their parts (empty is definite); everything else, sets included, is unlikely. Reported on the comparison.",
+  "description": "Put the variable first and the constant or literal second in comparisons, avoiding Yoda conditions; it reads the way you would say it.",
   "scope": {
     "include": [
       "**/*"
@@ -473,7 +473,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM300",
-        "message": "Yoda condition detected",
+        "message": "Swap the comparison so the variable comes first and the constant second, as in `x == 1`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim905-split-static-string.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim905-split-static-string",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM905 (split-static-string): `.split(...)` or `.rsplit(...)` called on a str literal (implicit concatenations included; not bytes, f- or t-strings), where `sep` (keyword, else first positional argument) is absent, `None` or a str literal, and `maxsplit` (keyword, else second positional argument) is absent or an integer literal, optionally negated, that fits in an i32 (`get_maxsplit_value`). Reported on the call.",
+  "description": "Use a list literal instead of calling split() or rsplit() on a string literal; the result is known in advance.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim910-dict-get-with-none-default.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim910-dict-get-with-none-default",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM910 (dict-get-with-none-default): `.get(key, None, ...)` whose second positional argument is `None`, with no keywords, called on a dict display or dict comprehension (through parentheses), or on a name whose binding is a dict (Ruff's `is_dict` through `resolves.binding`: a `def`'s `**kwargs`, a dict-typed value or `dict(...)`, a `dict`/`Dict` annotation or return annotation; unpacking carries no value).",
+  "description": "Drop the redundant None default from dict.get() calls; get() already returns None for a missing key.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-t100-debugger.json

@@ -3,7 +3,7 @@
   "id": "ruff-t100-debugger",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's T100 (debugger): imports of debugger modules (`is_debugger_import`) and of debugger functions (`from M import n` with `M.n` in `is_debugger_call`), once per imported name, matched by module with `resolves.imported`, relative imports by the module's text (`relative: \"text\"`: Ruff ignores the level). It also flags calls whose callee resolves to a debugger function (`resolve_qualified_name` through the file's imports, or the builtin `breakpoint`).",
+  "description": "Remove debugger imports and calls such as pdb.set_trace() and breakpoint() before committing.",
   "scope": {
     "include": [
       "**/*"
@@ -106,7 +106,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "T100",
-        "message": "Import for a debugger found",
+        "message": "Remove this debugger import of `$D` before committing.",
         "each": "D",
         "suppress": {
           "noqa": {
@@ -183,7 +183,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "T100",
-        "message": "Trace found: debugger used",
+        "message": "Remove this debugger call before committing.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/bandit-b406-import-xml-sax.json

@@ -1,73 +0,0 @@
-{
-  "format": "rerail.policy/v1",
-  "id": "bandit-b406-import-xml-sax",
-  "revision": 2,
-  "mode": "steer",
-  "description": "Detect direct imports of xml.sax. Port of Bandit 1.9.4's B406 import_xml_sax. Divergence: an import of only xml.sax.saxutils (`from xml.sax.saxutils import ...`, `from xml.sax import saxutils`, aliased or parenthesised) is not reported. saxutils holds XML writing and escaping helpers (escape, quoteattr, unescape, XMLGenerator) and no parser, so defusedxml, which the steer points to, has nothing to replace it with. `import xml.sax.saxutils` is still reported, since it also binds xml.sax and its parse functions (NER-1827).",
-  "scope": {
-    "include": [
-      "**/*.py"
-    ],
-    "exclude": []
-  },
-  "clauses": [
-    {
-      "id": "B406",
-      "forbid": {
-        "ast": {
-          "language": "python",
-          "rule": {
-            "any": [
-              {
-                "pattern": "import xml.sax"
-              },
-              {
-                "pattern": "import xml.sax as $ALIAS"
-              },
-              {
-                "pattern": "from xml.sax import $$$NAMES"
-              },
-              {
-                "pattern": "from xml import sax"
-              },
-              {
-                "pattern": "from xml import sax as $ALIAS"
-              }
-            ],
-            "not": {
-              "any": [
-                {
-                  "pattern": "from xml.sax.saxutils import $$$NAMES"
-                },
-                {
-                  "pattern": "from xml.sax import saxutils"
-                },
-                {
-                  "pattern": "from xml.sax import saxutils as $ALIAS"
-                },
-                {
-                  "pattern": "from xml.sax import (saxutils)"
-                },
-                {
-                  "pattern": "from xml.sax import (saxutils as $ALIAS)"
-                }
-              ]
-            }
-          }
-        }
-      },
-      "violation": {
-        "code": "B406",
-        "anchor": "witness.span",
-        "message": "xml.sax parsing may be vulnerable to XML attacks; use defusedxml or defuse the standard library.",
-        "suppress": {
-          "nosec": {
-            "codes": [
-              "B406"
-            ]
-          }
-        }
-      }
-    }
-  ]
-}

package/rules/bandit-b610-django-extra-used.json

@@ -1,268 +0,0 @@
-{
-  "format": "rerail.policy/v1",
-  "id": "bandit-b610-django-extra-used",
-  "revision": 2,
-  "mode": "steer",
-  "description": "Port of Bandit 1.9.4's B610 django_extra_used: a call of `extra` whose `where` or `tables` is not a list of plain strings, or whose `select` is not a dict of plain strings, bound to QuerySet.extra's six positional slots. Port of the kernel test b610_extra_with_a_non_literal_where_tables_or_select. Bandit's `# nosec` is honoured (`suppress.nosec`), as its recordings honour it. Divergence: Bandit reports a call of any function or method named `extra`; the port reports only a method call whose receiver looks like a Django QuerySet or Manager: a name or attribute named `objects`, `qs`, `QS`, `queryset`, `querysets`, `manager` or `managers`, alone or after an underscore-joined prefix (`User.objects`, `self.queryset`, `base_qs`, `_default_manager`); a call of `get_queryset`; a method call on such a receiver (`User.objects.filter(...)`); or `self` or `super()` inside a class with a base whose name ends in `QuerySet` (`QuerySet`, `SoftDeleteQuerySet`, `TreeQuerySet`) or is `Manager`, `BaseManager` or `BaseUserManager`, optionally dotted (`models.QuerySet`); a base that only ends in `Manager` (`AbstractContextManager`, `PluginManager`, `TreeManager`) does not count. A bare `extra(...)` call and `extra` on any other receiver (`parser.extra(...)`, `self.extra(...)` in an unrelated class) are not reported (NER-1827).",
-  "scope": {
-    "include": [
-      "**/*"
-    ],
-    "exclude": []
-  },
-  "clauses": [
-    {
-      "id": "django-extra-used",
-      "forbid": {
-        "ast": {
-          "language": "python",
-          "rule": {
-            "any": [
-              {
-                "pattern": "$R.extra($$$)"
-              }
-            ],
-            "all": [
-              {
-                "has": {
-                  "field": "function",
-                  "has": {
-                    "field": "object",
-                    "matches": "queryset-receiver"
-                  }
-                }
-              },
-              {
-                "any": [
-                  {
-                    "arguments": {
-                      "signature": [
-                        "select",
-                        "where",
-                        "params",
-                        "tables",
-                        "order_by",
-                        "select_params"
-                      ],
-                      "bind": {
-                        "W": "where"
-                      }
-                    },
-                    "has": {
-                      "stopBy": "end",
-                      "pattern": "$W",
-                      "not": {
-                        "matches": "strings"
-                      }
-                    }
-                  },
-                  {
-                    "arguments": {
-                      "signature": [
-                        "select",
-                        "where",
-                        "params",
-                        "tables",
-                        "order_by",
-                        "select_params"
-                      ],
-                      "bind": {
-                        "T": "tables"
-                      }
-                    },
-                    "has": {
-                      "stopBy": "end",
-                      "pattern": "$T",
-                      "not": {
-                        "matches": "strings"
-                      }
-                    }
-                  },
-                  {
-                    "arguments": {
-                      "signature": [
-                        "select",
-                        "where",
-                        "params",
-                        "tables",
-                        "order_by",
-                        "select_params"
-                      ],
-                      "bind": {
-                        "S": "select"
-                      }
-                    },
-                    "has": {
-                      "stopBy": "end",
-                      "pattern": "$S",
-                      "not": {
-                        "matches": "string-pairs"
-                      }
-                    }
-                  }
-                ]
-              }
-            ]
-          },
-          "utils": {
-            "queryset-receiver": {
-              "any": [
-                {
-                  "kind": "identifier",
-                  "regex": "^(?:[A-Za-z0-9_]*_)?(?:qs|QS|querysets?|objects|managers?)$"
-                },
-                {
-                  "kind": "attribute",
-                  "has": {
-                    "field": "attribute",
-                    "regex": "^(?:[A-Za-z0-9_]*_)?(?:qs|QS|querysets?|objects|managers?)$"
-                  }
-                },
-                {
-                  "kind": "call",
-                  "has": {
-                    "field": "function",
-                    "kind": "attribute",
-                    "has": {
-                      "field": "object",
-                      "matches": "queryset-receiver"
-                    }
-                  }
-                },
-                {
-                  "kind": "call",
-                  "has": {
-                    "field": "function",
-                    "any": [
-                      {
-                        "kind": "identifier",
-                        "regex": "^get_queryset$"
-                      },
-                      {
-                        "kind": "attribute",
-                        "has": {
-                          "field": "attribute",
-                          "regex": "^get_queryset$"
-                        }
-                      }
-                    ]
-                  }
-                },
-                {
-                  "any": [
-                    {
-                      "kind": "identifier",
-                      "regex": "^self$"
-                    },
-                    {
-                      "pattern": "super()"
-                    }
-                  ],
-                  "inside": {
-                    "stopBy": "end",
-                    "kind": "class_definition",
-                    "has": {
-                      "field": "superclasses",
-                      "regex": "(?:^|[(,\\s])(?:[A-Za-z_][A-Za-z0-9_]*\\.)*(?:[A-Za-z0-9_]*QuerySet|Manager|BaseManager|BaseUserManager)\\b"
-                    }
-                  }
-                }
-              ]
-            },
-            "string": {
-              "any": [
-                {
-                  "kind": "string",
-                  "not": {
-                    "regex": "^[A-Za-z]*[fFbBtT]"
-                  }
-                },
-                {
-                  "kind": "concatenated_string",
-                  "not": {
-                    "has": {
-                      "kind": "string",
-                      "regex": "^[A-Za-z]*[fFbBtT]"
-                    }
-                  }
-                }
-              ]
-            },
-            "strings": {
-              "kind": "list",
-              "not": {
-                "has": {
-                  "stopBy": "neighbor",
-                  "not": {
-                    "any": [
-                      {
-                        "matches": "string"
-                      },
-                      {
-                        "regex": "^[\\[\\],]$"
-                      },
-                      {
-                        "kind": "comment"
-                      }
-                    ]
-                  }
-                }
-              }
-            },
-            "string-pairs": {
-              "kind": "dictionary",
-              "not": {
-                "has": {
-                  "stopBy": "neighbor",
-                  "not": {
-                    "any": [
-                      {
-                        "kind": "pair",
-                        "not": {
-                          "has": {
-                            "stopBy": "neighbor",
-                            "not": {
-                              "any": [
-                                {
-                                  "matches": "string"
-                                },
-                                {
-                                  "regex": "^:$"
-                                },
-                                {
-                                  "kind": "comment"
-                                }
-                              ]
-                            }
-                          }
-                        }
-                      },
-                      {
-                        "regex": "^[{},]$"
-                      },
-                      {
-                        "kind": "comment"
-                      }
-                    ]
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      "violation": {
-        "anchor": "witness.span",
-        "code": "B610",
-        "message": "Bandit B610 (django-extra-used)",
-        "suppress": {
-          "nosec": {
-            "codes": [
-              "B610"
-            ]
-          }
-        }
-      }
-    }
-  ]
-}