@neralabs/rerail-pack-python 0.1.1

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

@@ -0,0 +1,182 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-try-block-exception",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "dotted": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "dotted"
+                  }
+                }
+              ]
+            },
+            "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"
+                  }
+                }
+              ]
+            },
+            "name-slot": {
+              "any": [
+                {
+                  "matches": "type-slot"
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "tuple",
+                    "matches": "type-slot"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "except_clause"
+                  },
+                  "any": [
+                    {
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "regex": "^,$"
+                      }
+                    },
+                    {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "^,$"
+                      }
+                    }
+                  ]
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "name-slot"
+                  }
+                }
+              ]
+            },
+            "lists-e": {
+              "kind": "except_clause",
+              "has": {
+                "stopBy": {
+                  "kind": "block"
+                },
+                "pattern": "$E",
+                "matches": "dotted",
+                "all": [
+                  {
+                    "matches": "name-slot"
+                  }
+                ]
+              }
+            }
+          },
+          "rule": {
+            "matches": "dotted",
+            "pattern": "$E",
+            "all": [
+              {
+                "matches": "name-slot"
+              },
+              {
+                "not": {
+                  "follows": {
+                    "stopBy": "end",
+                    "pattern": "$E"
+                  }
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": {
+                    "kind": "except_clause"
+                  },
+                  "kind": "except_clause",
+                  "follows": {
+                    "stopBy": "end",
+                    "matches": "lists-e"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B025",
+        "message": "try-except block with duplicate exception `$E`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B025"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,57 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "star-arg-unpacking-after-keyword-arg",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "list_splat",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "argument_list",
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "call"
+              }
+            },
+            "follows": {
+              "stopBy": "end",
+              "any": [
+                {
+                  "kind": "keyword_argument"
+                },
+                {
+                  "kind": "dictionary_splat"
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B026",
+        "message": "Star-arg unpacking after a keyword argument is strongly discouraged",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B026"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,177 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "no-explicit-stacklevel",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "warnings-warn": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "warnings.warn"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "warnings-warn"
+                  }
+                }
+              ]
+            },
+            "warn-args": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "call"
+                  },
+                  "precedes": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "argument_list",
+                        "not": {
+                          "any": [
+                            {
+                              "has": {
+                                "stopBy": "neighbor",
+                                "kind": "keyword_argument",
+                                "all": [
+                                  {
+                                    "has": {
+                                      "stopBy": "neighbor",
+                                      "kind": "identifier",
+                                      "regex": "^(skip_file_prefixes)$",
+                                      "precedes": {
+                                        "stopBy": "neighbor",
+                                        "regex": "^=$"
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "has": {
+                                      "stopBy": "neighbor",
+                                      "follows": {
+                                        "stopBy": "neighbor",
+                                        "regex": "^=$"
+                                      },
+                                      "not": {
+                                        "kind": "tuple",
+                                        "regex": "^\\(\\s*\\)$"
+                                      }
+                                    }
+                                  }
+                                ]
+                              }
+                            },
+                            {
+                              "has": {
+                                "stopBy": "neighbor",
+                                "any": [
+                                  {
+                                    "kind": "list_splat"
+                                  },
+                                  {
+                                    "kind": "dictionary_splat"
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        "kind": "generator_expression"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "warn-args"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "any": [
+              {
+                "kind": "attribute"
+              },
+              {
+                "kind": "identifier"
+              }
+            ],
+            "all": [
+              {
+                "matches": "warnings-warn"
+              },
+              {
+                "matches": "warn-args"
+              },
+              {
+                "inside": {
+                  "stopBy": {
+                    "kind": "call"
+                  },
+                  "kind": "call",
+                  "arguments": {
+                    "signature": [
+                      "message",
+                      "category",
+                      "stacklevel"
+                    ],
+                    "absent": [
+                      "stacklevel"
+                    ],
+                    "mode": "syntactic"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B028",
+        "message": "No explicit `stacklevel` keyword argument found",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B028"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,102 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "except-with-empty-tuple",
+      "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"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "except_clause",
+            "has": {
+              "stopBy": {
+                "kind": "block"
+              },
+              "kind": "tuple",
+              "matches": "type-slot",
+              "not": {
+                "has": {
+                  "stopBy": "neighbor",
+                  "not": {
+                    "any": [
+                      {
+                        "regex": "^[(),]$"
+                      },
+                      {
+                        "kind": "comment"
+                      }
+                    ]
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B029",
+        "message": "Using `except ():` with an empty tuple does not catch anything; add exceptions to handle",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B029"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,157 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unintentional-type-annotation",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "name": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "name"
+                  }
+                }
+              ]
+            },
+            "non-self-name": {
+              "any": [
+                {
+                  "kind": "identifier",
+                  "not": {
+                    "regex": "^self$"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "non-self-name"
+                  }
+                }
+              ]
+            },
+            "target": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "subscript",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "not": {
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "(?s)."
+                          }
+                        },
+                        "matches": "name"
+                      }
+                    },
+                    {
+                      "kind": "attribute",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "not": {
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "(?s)."
+                          }
+                        },
+                        "matches": "non-self-name"
+                      }
+                    },
+                    {
+                      "kind": "tuple_pattern",
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "regex": "^,$"
+                        }
+                      },
+                      "has": {
+                        "stopBy": "neighbor",
+                        "matches": "target"
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "target"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "assignment",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "expression_statement"
+            },
+            "all": [
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "type"
+                }
+              },
+              {
+                "not": {
+                  "has": {
+                    "stopBy": "neighbor",
+                    "regex": "^=$"
+                  }
+                }
+              },
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "matches": "target"
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B032",
+        "message": "Possible unintentional type annotation (using `:`). Did you mean to assign (using `=`)?",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B032"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}