@neralabs/rerail-pack-python 0.1.1

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

@@ -0,0 +1,73 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "undefined-local-with-import-star",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "import_from_statement",
+            "has": {
+              "stopBy": "neighbor",
+              "kind": "wildcard_import",
+              "follows": {
+                "stopBy": "end",
+                "any": [
+                  {
+                    "kind": "dotted_name"
+                  },
+                  {
+                    "kind": "relative_import"
+                  }
+                ],
+                "pattern": "$MODULE"
+              }
+            },
+            "not": {
+              "has": {
+                "stopBy": "neighbor",
+                "any": [
+                  {
+                    "kind": "dotted_name",
+                    "regex": "^__future__$"
+                  },
+                  {
+                    "kind": "relative_import",
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "dotted_name",
+                      "regex": "^__future__$"
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F403",
+        "message": "`from $MODULE import *` used; unable to detect undefined names",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F403"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,87 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "undefined-local-with-import-star-usage",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "star-in-string": {
+              "any": [
+                {
+                  "kind": "string"
+                },
+                {
+                  "kind": "concatenated_string"
+                }
+              ],
+              "parse": {
+                "grammar": "annotation",
+                "has": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "identifier",
+                      "resolves": {
+                        "unresolved": "star"
+                      },
+                      "capture": "NAME"
+                    },
+                    {
+                      "matches": "star-in-string"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "rule": {
+            "any": [
+              {
+                "any": [
+                  {
+                    "kind": "identifier"
+                  },
+                  {
+                    "kind": "string"
+                  }
+                ],
+                "pattern": "$NAME",
+                "resolves": {
+                  "unresolved": "star"
+                }
+              },
+              {
+                "matches": "star-in-string"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.NAME",
+        "code": "F405",
+        "message": "`$NAME` may be undefined, or defined from star imports",
+        "each": "NAME",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F405"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,39 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "undefined-local-with-nested-import-star-usage",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "import_from_statement",
+            "has": {
+              "stopBy": "neighbor",
+              "kind": "wildcard_import",
+              "follows": { "stopBy": "end", "any": [{ "kind": "dotted_name" }, { "kind": "relative_import" }], "pattern": "$MODULE" }
+            },
+            "inside": { "stopBy": "end", "any": [{ "kind": "function_definition" }, { "kind": "class_definition" }] }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F406",
+        "message": "`from $MODULE import *` only allowed at module level",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F406"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,56 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "future-feature-not-defined",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "known-feature": {
+              "kind": "dotted_name",
+              "regex": "^(nested_scopes|generators|division|absolute_import|with_statement|print_function|unicode_literals|barry_as_FLUFL|generator_stop|annotations)$"
+            },
+            "future-import": {
+              "any": [
+                { "kind": "future_import_statement" },
+                {
+                  "kind": "import_from_statement",
+                  "has": { "stopBy": "neighbor", "kind": "relative_import", "has": { "stopBy": "neighbor", "kind": "dotted_name", "resolves": { "imported": ["__future__"], "relative": "text" } } }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "any": [
+              { "kind": "dotted_name", "not": { "matches": "known-feature" }, "pattern": "$NAME" },
+              {
+                "kind": "aliased_import",
+                "has": { "stopBy": "neighbor", "kind": "dotted_name", "not": { "matches": "known-feature" }, "pattern": "$NAME" }
+              },
+              { "kind": "wildcard_import", "pattern": "$NAME" }
+            ],
+            "inside": { "stopBy": "neighbor", "matches": "future-import" }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F407",
+        "message": "Future feature `$NAME` is not defined",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F407"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,88 @@
+{
+  "format": "rerail.policy/v1",
+  "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).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-invalid-format",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "plain-string": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "kind": "string",
+                      "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                    }
+                  }
+                }
+              ]
+            },
+            "format-string": {
+              "any": [
+                {
+                  "matches": "plain-string",
+                  "parse": {
+                    "grammar": "percentFormat",
+                    "has": {
+                      "kind": "error",
+                      "not": {
+                        "value": {
+                          "regex": "^unsupported format character"
+                        }
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F501",
+        "message": "`%`-format string has invalid format string",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F501"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,127 @@
+{
+  "format": "rerail.policy/v1",
+  "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).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-expected-mapping",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "plain-string": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "kind": "string",
+                      "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                    }
+                  }
+                }
+              ]
+            },
+            "format-string": {
+              "any": [
+                {
+                  "matches": "plain-string",
+                  "parse": {
+                    "grammar": "percentFormat",
+                    "not": {
+                      "has": {
+                        "kind": "error"
+                      }
+                    },
+                    "has": {
+                      "kind": "placeholder",
+                      "stopBy": "end",
+                      "has": {
+                        "kind": "mapping_key"
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            },
+            "operand": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "list"
+                    },
+                    {
+                      "kind": "tuple"
+                    },
+                    {
+                      "kind": "set"
+                    },
+                    {
+                      "kind": "list_comprehension"
+                    },
+                    {
+                      "kind": "set_comprehension"
+                    },
+                    {
+                      "kind": "generator_expression"
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "operand"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            },
+            "R": {
+              "matches": "operand"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F502",
+        "message": "`%`-format string expected mapping but got sequence",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F502"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,127 @@
+{
+  "format": "rerail.policy/v1",
+  "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).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-expected-sequence",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "plain-string": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "kind": "string",
+                      "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                    }
+                  }
+                }
+              ]
+            },
+            "format-string": {
+              "any": [
+                {
+                  "matches": "plain-string",
+                  "parse": {
+                    "grammar": "percentFormat",
+                    "not": {
+                      "has": {
+                        "kind": "error"
+                      }
+                    },
+                    "count": {
+                      "has": {
+                        "stopBy": "end",
+                        "any": [
+                          {
+                            "kind": "placeholder",
+                            "not": {
+                              "has": {
+                                "kind": "mapping_key"
+                              }
+                            }
+                          },
+                          {
+                            "kind": "star"
+                          }
+                        ]
+                      },
+                      "min": 2
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            },
+            "operand": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "dictionary"
+                    },
+                    {
+                      "kind": "dictionary_comprehension"
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "operand"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            },
+            "R": {
+              "matches": "operand"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F503",
+        "message": "`%`-format string expected sequence but got mapping",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F503"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,46 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-extra-named-arguments",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S % $R",
+            "formatArgs": {
+              "style": "percent",
+              "string": "S",
+              "args": "R",
+              "unused": {
+                "kind": "pair"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F504",
+        "message": "`%`-format string has unused named argument(s)",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F504"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}