@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-b033-duplicate-value.json

@@ -0,0 +1,129 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b033-duplicate-value",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B033 (duplicate-value): a literal element of a set display (string, bytes, number, boolean, `None`, `...`, not an f- or t-string; parentheses are transparent) equal to an earlier literal element. Equality is Ruff's HashableExpr (`compare` `text: \"structure-hash\"`): numbers fold by value (`True == 1 == 1.0 == 0x1`), strings by decoded value (`'a' == \"\\x61\"`, implicit concatenation joined), and an int of 2**64 or more by its token.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-value",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "literal": {
+              "any": [
+                {
+                  "kind": "string",
+                  "regex": "^[rRuUbB]{0,2}['\"]"
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "string",
+                      "not": {
+                        "regex": "^[rRuUbB]{0,2}['\"]"
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "ellipsis"
+                }
+              ]
+            },
+            "literal-p": {
+              "any": [
+                {
+                  "matches": "literal"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "literal-p"
+                  }
+                }
+              ]
+            },
+            "dup-slot": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "set"
+                  },
+                  "count": {
+                    "follows": {
+                      "stopBy": "end",
+                      "matches": "literal-p",
+                      "pattern": "$F",
+                      "compare": {
+                        "left": "F",
+                        "op": "eq",
+                        "right": "V",
+                        "text": "structure-hash"
+                      }
+                    },
+                    "min": 1
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "dup-slot"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "matches": "literal",
+            "pattern": "$V",
+            "all": [
+              {
+                "matches": "dup-slot"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B033",
+        "message": "Sets should not contain duplicate item `$V`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B033"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b034-re-sub-positional-args.json

@@ -0,0 +1,159 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b034-re-sub-positional-args",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B034 (re-sub-positional-args): a call to `re.sub` or `re.subn` with more than three positional arguments, or to `re.split` with more than two (starred arguments count). The callee resolves with `resolves` (imports and shadowing as Ruff's semantic model sees them). Reported on the call.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "re-sub-positional-args",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "re-sub": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "re.sub",
+                      "re.subn"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "re-sub"
+                  }
+                }
+              ]
+            },
+            "re-split": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "re.split"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "re-split"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "any": [
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "argument_list",
+                  "count": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "kind": "keyword_argument"
+                          },
+                          {
+                            "kind": "dictionary_splat"
+                          },
+                          {
+                            "kind": "comment"
+                          },
+                          {
+                            "regex": "^[(),]$"
+                          }
+                        ]
+                      }
+                    },
+                    "min": 4
+                  },
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "matches": "re-sub"
+                  }
+                }
+              },
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "argument_list",
+                  "count": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "kind": "keyword_argument"
+                          },
+                          {
+                            "kind": "dictionary_splat"
+                          },
+                          {
+                            "kind": "comment"
+                          },
+                          {
+                            "regex": "^[(),]$"
+                          }
+                        ]
+                      }
+                    },
+                    "min": 3
+                  },
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "matches": "re-split"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B034",
+        "message": "`re.sub` should pass `count` and `flags` as keyword arguments to avoid confusion due to unintuitive argument positions",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B034"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b039-mutable-contextvar-default.json

@@ -0,0 +1,281 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b039-mutable-contextvar-default",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B039 (mutable-contextvar-default): the `default=` of a `contextvars.ContextVar(...)` call (the callee may be subscripted) is a list, dict or set display or comprehension, or a call to anything other than a function Ruff knows returns an immutable value (`is_immutable_return_type`: `datetime`, `decimal`, `fractions`, `operator`, `pathlib.Path`, `types.MappingProxyType`, `re.compile`, immutable builtins, and Ruff's option `flake8-bugbear.extend-immutable-calls`). Names resolve with `resolves` (imports, and builtins only when unshadowed). Reported on the default, inside any parentheses.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "options",
+      "define": {
+        "options": {
+          "flake8-bugbear.extend-immutable-calls": {
+            "type": "array",
+            "items": "string",
+            "default": [],
+            "description": "Qualified names of further calls that return immutable values."
+          }
+        }
+      }
+    },
+    {
+      "id": "mutable-contextvar-default",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "contextvar": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "contextvars.ContextVar"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "contextvar"
+                  }
+                }
+              ]
+            },
+            "immutable-func": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute"
+                }
+              ],
+              "resolves": {
+                "global": [
+                  "bool",
+                  "bytes",
+                  "complex",
+                  "float",
+                  "frozenset",
+                  "int",
+                  "range",
+                  "str",
+                  "tuple",
+                  "slice",
+                  "frozendict"
+                ],
+                "import": [
+                  "datetime.date",
+                  "datetime.datetime",
+                  "datetime.time",
+                  "datetime.timedelta",
+                  "datetime.timezone",
+                  "datetime.tzinfo",
+                  "decimal.Decimal",
+                  "fractions.Fraction",
+                  "operator.attrgetter",
+                  "operator.itemgetter",
+                  "operator.methodcaller",
+                  "pathlib.Path",
+                  "types.MappingProxyType",
+                  "re.compile",
+                  {
+                    "$option": "flake8-bugbear.extend-immutable-calls",
+                    "spread": true
+                  }
+                ]
+              }
+            },
+            "callee-of-contextvar": {
+              "any": [
+                {
+                  "matches": "contextvar"
+                },
+                {
+                  "kind": "subscript",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "contextvar"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "callee-of-contextvar"
+                  }
+                }
+              ]
+            },
+            "immutable-callee": {
+              "any": [
+                {
+                  "matches": "immutable-func"
+                },
+                {
+                  "kind": "subscript",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "immutable-func"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "immutable-callee"
+                  }
+                }
+              ]
+            },
+            "mutable-default": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "list"
+                    },
+                    {
+                      "kind": "dictionary"
+                    },
+                    {
+                      "kind": "set"
+                    },
+                    {
+                      "kind": "list_comprehension"
+                    },
+                    {
+                      "kind": "dictionary_comprehension"
+                    },
+                    {
+                      "kind": "set_comprehension"
+                    }
+                  ]
+                },
+                {
+                  "kind": "call",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "(?s)."
+                        }
+                      },
+                      "matches": "immutable-callee"
+                    }
+                  }
+                }
+              ]
+            },
+            "default-slot": {
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^=$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "keyword_argument",
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "identifier",
+                      "regex": "^default$",
+                      "precedes": {
+                        "stopBy": "neighbor",
+                        "regex": "^=$"
+                      }
+                    },
+                    "not": {
+                      "follows": {
+                        "stopBy": "end",
+                        "kind": "keyword_argument",
+                        "all": [
+                          {
+                            "has": {
+                              "stopBy": "neighbor",
+                              "kind": "identifier",
+                              "regex": "^(default)$",
+                              "precedes": {
+                                "stopBy": "neighbor",
+                                "regex": "^=$"
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    },
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "argument_list",
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "matches": "callee-of-contextvar"
+                      }
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "default-slot"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "matches": "mutable-default",
+            "all": [
+              {
+                "matches": "default-slot"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B039",
+        "message": "Do not use mutable data structures for `ContextVar` defaults",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B039"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}