@neralabs/rerail-pack-python 0.1.1

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

@@ -0,0 +1,199 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "none-comparison",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "constant": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "constant"
+                  }
+                },
+                {
+                  "kind": "tuple",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "matches": "constant"
+                          },
+                          {
+                            "regex": "^[(),]$"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "constant-non-singleton": {
+              "all": [
+                {
+                  "matches": "constant"
+                },
+                {
+                  "not": {
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            },
+            "compared-operand": {
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "comparison_operator"
+              },
+              "any": [
+                {
+                  "all": [
+                    {
+                      "not": {
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "(?s)."
+                        }
+                      }
+                    },
+                    {
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "regex": "^(==|!=)$",
+                        "precedes": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "matches": "constant-non-singleton"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^(==|!=)$",
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "matches": "constant-non-singleton"
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "operand": {
+              "any": [
+                {
+                  "matches": "compared-operand"
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "operand"
+                  }
+                }
+              ]
+            },
+            "singleton": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "none",
+            "matches": "operand"
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "E711",
+        "message": "Comparison to `None` should be `cond is None`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E711"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-e721-type-comparison.json

@@ -0,0 +1,293 @@
+{
+  "format": "rerail.policy/v1",
+  "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).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "type-comparison",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "type-callee": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "global": [
+                      "type"
+                    ],
+                    "import": [
+                      "builtins.type"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "type-callee"
+                  }
+                }
+              ]
+            },
+            "is-type": {
+              "any": [
+                {
+                  "kind": "call",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "type-callee"
+                  }
+                },
+                {
+                  "kind": "identifier",
+                  "resolves": {
+                    "global": [
+                      "bool",
+                      "bytearray",
+                      "bytes",
+                      "classmethod",
+                      "complex",
+                      "dict",
+                      "enumerate",
+                      "filter",
+                      "float",
+                      "frozenset",
+                      "int",
+                      "list",
+                      "map",
+                      "memoryview",
+                      "object",
+                      "property",
+                      "range",
+                      "reversed",
+                      "set",
+                      "slice",
+                      "staticmethod",
+                      "str",
+                      "super",
+                      "tuple",
+                      "type",
+                      "zip",
+                      "ArithmeticError",
+                      "AssertionError",
+                      "AttributeError",
+                      "BaseException",
+                      "BlockingIOError",
+                      "BrokenPipeError",
+                      "BufferError",
+                      "BytesWarning",
+                      "ChildProcessError",
+                      "ConnectionAbortedError",
+                      "ConnectionError",
+                      "ConnectionRefusedError",
+                      "ConnectionResetError",
+                      "DeprecationWarning",
+                      "EnvironmentError",
+                      "EOFError",
+                      "Exception",
+                      "FileExistsError",
+                      "FileNotFoundError",
+                      "FloatingPointError",
+                      "FutureWarning",
+                      "GeneratorExit",
+                      "ImportError",
+                      "ImportWarning",
+                      "IndentationError",
+                      "IndexError",
+                      "InterruptedError",
+                      "IOError",
+                      "IsADirectoryError",
+                      "KeyboardInterrupt",
+                      "KeyError",
+                      "LookupError",
+                      "MemoryError",
+                      "ModuleNotFoundError",
+                      "NameError",
+                      "NotADirectoryError",
+                      "NotImplementedError",
+                      "OSError",
+                      "OverflowError",
+                      "PendingDeprecationWarning",
+                      "PermissionError",
+                      "ProcessLookupError",
+                      "RecursionError",
+                      "ReferenceError",
+                      "ResourceWarning",
+                      "RuntimeError",
+                      "RuntimeWarning",
+                      "StopAsyncIteration",
+                      "StopIteration",
+                      "SyntaxError",
+                      "SyntaxWarning",
+                      "SystemError",
+                      "SystemExit",
+                      "TabError",
+                      "TimeoutError",
+                      "TypeError",
+                      "UnboundLocalError",
+                      "UnicodeDecodeError",
+                      "UnicodeEncodeError",
+                      "UnicodeError",
+                      "UnicodeTranslateError",
+                      "UnicodeWarning",
+                      "UserWarning",
+                      "ValueError",
+                      "Warning",
+                      "ZeroDivisionError"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "is-type"
+                  }
+                }
+              ]
+            },
+            "dtype-callee": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "numpy.dtype"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "dtype-callee"
+                  }
+                }
+              ]
+            },
+            "is-dtype": {
+              "any": [
+                {
+                  "kind": "attribute",
+                  "pattern": "$OBJ.dtype"
+                },
+                {
+                  "kind": "call",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "dtype-callee"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "is-dtype"
+                  }
+                }
+              ]
+            },
+            "eq-op": {
+              "regex": "^(?:==|!=)$"
+            },
+            "offending-op": {
+              "all": [
+                {
+                  "matches": "eq-op"
+                },
+                {
+                  "any": [
+                    {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "matches": "is-type"
+                      }
+                    },
+                    {
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "matches": "is-type"
+                      }
+                    }
+                  ]
+                },
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "matches": "is-dtype"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "matches": "is-dtype"
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "matches": "offending-op",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "comparison_operator",
+              "pattern": "$CMP"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.CMP",
+        "code": "E721",
+        "message": "Use `is` and `is not` for type comparisons, or `isinstance()` for isinstance checks",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E721"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-e722-bare-except.json

@@ -0,0 +1,57 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "bare-except",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "regex": "^except$",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "except_clause",
+              "not": {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "block",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "raise_statement",
+                    "regex": "^raise$"
+                  }
+                }
+              }
+            },
+            "precedes": {
+              "stopBy": "neighbor",
+              "regex": "^:$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "E722",
+        "message": "Do not use bare `except`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E722"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-e742-ambiguous-class-name.json

@@ -0,0 +1,47 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-e742-ambiguous-class-name",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's E742 (ambiguous-class-name): a class named `l`, `I` or `O`, reported on the name.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "ambiguous-class-name",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "regex": "^(?<NAME>[lIO])$",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "class_definition"
+            },
+            "follows": {
+              "stopBy": "neighbor",
+              "regex": "^(?:class|def)$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "E742",
+        "message": "Ambiguous class name: `$NAME`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E742"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-e743-ambiguous-function-name.json

@@ -0,0 +1,47 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-e743-ambiguous-function-name",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's E743 (ambiguous-function-name): a function named `l`, `I` or `O`, reported on the name. Includes `async def` and methods.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "ambiguous-function-name",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "regex": "^(?<NAME>[lIO])$",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "function_definition"
+            },
+            "follows": {
+              "stopBy": "neighbor",
+              "regex": "^(?:class|def)$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "E743",
+        "message": "Ambiguous function name: `$NAME`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "E743"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}