@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-f822-undefined-export.json

@@ -0,0 +1,55 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f822-undefined-export",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F822 (undefined-export) with default settings, on the engine's name resolution (M10a `resolves.unresolved` on `__all__` entries): a string entry of a static module `__all__` definition (Ruff's extract_dunder_all_names) (an implicit concatenation is one entry) that names no module binding (a bare annotation included) and no builtin, in a module without a star import. `__init__.py` is exempt (Ruff reports it only in preview). Reported on the string.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": [
+      "**/__init__.py",
+      "**/__init__.pyi",
+      "__init__.py",
+      "__init__.pyi"
+    ]
+  },
+  "clauses": [
+    {
+      "id": "undefined-export",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "any": [
+              {
+                "kind": "string"
+              },
+              {
+                "kind": "concatenated_string"
+              }
+            ],
+            "pattern": "$S",
+            "resolves": {
+              "unresolved": true
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F822",
+        "message": "Undefined name $S in `__all__`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F822"
+            ],
+            "parent": "statement"
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f823-undefined-local.json

@@ -0,0 +1,42 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f823-undefined-local",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F823 (undefined-local) with default settings, on the engine's name resolution (M10a `resolves.beforeLocal`, Ruff's undefined_local): a function's first read of a name that resolves to an enclosing function's or the module's binding which the function's own later binding of the name shadows, where that binding is the function's first and latest of the name (not `global`, `nonlocal` or `del`). Reported on the read. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F823.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "undefined-local",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "pattern": "$N",
+            "resolves": {
+              "beforeLocal": true
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F823",
+        "message": "Local variable `$N` referenced before assignment",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F823"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f842-unused-annotation.json

@@ -0,0 +1,51 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f842-unused-annotation",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F842 (unused-annotation) with default settings (`dummy-variable-rgx` = `^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$`), on the engine's usedness (M10a `binds` with form `annotation`, Ruff's unused_annotation): the latest binding of a name in a function or lambda scope that is a bare annotation (`x: int`, `(x): int`) nothing reads, not a dummy name. Names in strings Ruff parses as type definitions are reads (M11a).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unused-annotation",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "pattern": "$N",
+            "binds": {
+              "form": "annotation",
+              "scope": [
+                "function",
+                "lambda"
+              ],
+              "latest": true,
+              "used": false
+            },
+            "not": {
+              "regex": "^(?:_+|_+[a-zA-Z0-9_]*[a-zA-Z0-9])$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F842",
+        "message": "Local variable `$N` is annotated but never used",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F842"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f901-raise-not-implemented.json

@@ -0,0 +1,97 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f901-raise-not-implemented",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F901 (raise-not-implemented) with default settings: the exception of a `raise` (not its `from` cause) that is the name `NotImplemented` or a call whose callee is that name, parentheses transparent. Reported on the name. Ruff matches the name itself, not the builtin binding.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "raise-not-implemented",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "raised": {
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^raise$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "raise_statement"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "raised"
+                  }
+                },
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "call",
+                    "matches": "raised-direct"
+                  }
+                }
+              ]
+            },
+            "raised-direct": {
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^raise$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "raise_statement"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "raised-direct"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "identifier",
+            "regex": "^NotImplemented$",
+            "matches": "raised"
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F901",
+        "message": "`raise NotImplemented` should be `raise NotImplementedError`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F901"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-pie794-duplicate-class-field-definition.json

@@ -0,0 +1,157 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie794-duplicate-class-field-definition",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE794 (duplicate-class-field-definition): in a class body, an assignment or annotated assignment to a name `N` whose value does not mention `N`, after an earlier such definition of `N` in the same body.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-class-field-definition",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "target-n": {
+              "any": [
+                {
+                  "kind": "identifier",
+                  "pattern": "$N"
+                },
+                {
+                  "any": [
+                    {
+                      "any": [
+                        {
+                          "kind": "parenthesized_expression"
+                        },
+                        {
+                          "kind": "tuple_pattern"
+                        }
+                      ]
+                    }
+                  ],
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "regex": "^,$"
+                    }
+                  },
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "target-n"
+                  }
+                }
+              ]
+            },
+            "field-def": {
+              "kind": "expression_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "kind": "assignment",
+                "all": [
+                  {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "(?s)."
+                        }
+                      },
+                      "matches": "target-n"
+                    }
+                  },
+                  {
+                    "not": {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "assignment"
+                      }
+                    }
+                  },
+                  {
+                    "not": {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "^=$"
+                        },
+                        "any": [
+                          {
+                            "kind": "identifier",
+                            "pattern": "$N"
+                          },
+                          {
+                            "has": {
+                              "stopBy": "end",
+                              "kind": "identifier",
+                              "pattern": "$N",
+                              "not": {
+                                "any": [
+                                  {
+                                    "follows": {
+                                      "stopBy": "neighbor",
+                                      "regex": "^\\.$"
+                                    }
+                                  },
+                                  {
+                                    "inside": {
+                                      "stopBy": "neighbor",
+                                      "kind": "keyword_argument"
+                                    },
+                                    "precedes": {
+                                      "stopBy": "neighbor",
+                                      "regex": "^=$"
+                                    }
+                                  }
+                                ]
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "rule": {
+            "matches": "field-def",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "block",
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "class_definition"
+              }
+            },
+            "follows": {
+              "stopBy": "end",
+              "matches": "field-def"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE794",
+        "message": "Class field `$N` is defined multiple times",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE794"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}