@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-pie796-non-unique-enums.json

@@ -0,0 +1,460 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie796-non-unique-enums",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE796 (non-unique-enums): in a class with an `enum.Enum` base, a plain assignment whose value equals the value of an earlier assignment in the same body as Ruff's ComparableExpr (`text: \"structure\"`: literals by type and value, `1 == 0x1`, `'a' == \"a\"`, `-1 == -(1)`, not `1 == 1.0 == True`; names compared without NFKC normalization); `enum.auto()` values (alone or in a tuple) are skipped, and in stubs (`.pyi`) so are `...` and `typing.cast(T, ...)`. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/PIE796.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it, and its `.py`/`.pyi` split read per file (`ast.file.path`): the suite's `select_when` gate holds wherever a matching file exists anywhere in the workspace, so in a repository it would read stubs as modules and modules as stubs.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "shared",
+      "define": {
+        "language": "python",
+        "utils": {
+          "auto-call": {
+            "any": [
+              {
+                "kind": "call",
+                "has": {
+                  "stopBy": "neighbor",
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "matches": "enum-auto"
+                }
+              },
+              {
+                "kind": "parenthesized_expression",
+                "has": {
+                  "stopBy": "neighbor",
+                  "matches": "auto-call"
+                }
+              }
+            ]
+          },
+          "enum-auto": {
+            "any": [
+              {
+                "kind": "identifier"
+              },
+              {
+                "kind": "attribute"
+              }
+            ],
+            "resolves": {
+              "import": [
+                "enum.auto"
+              ]
+            }
+          },
+          "enum-base": {
+            "any": [
+              {
+                "kind": "identifier"
+              },
+              {
+                "kind": "attribute"
+              }
+            ],
+            "resolves": {
+              "import": [
+                "enum.Enum"
+              ]
+            }
+          }
+        }
+      }
+    },
+    {
+      "id": "non-unique-enums",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "member": {
+              "params": [
+                "X"
+              ],
+              "rule": {
+                "kind": "expression_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "assignment",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "regex": "^:$"
+                    }
+                  },
+                  "has": {
+                    "stopBy": {
+                      "not": {
+                        "kind": "assignment"
+                      }
+                    },
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "^=$"
+                    },
+                    "not": {
+                      "kind": "assignment"
+                    },
+                    "pattern": "$X",
+                    "all": [
+                      {
+                        "not": {
+                          "any": [
+                            {
+                              "matches": "auto-call"
+                            },
+                            {
+                              "any": [
+                                {
+                                  "any": [
+                                    {
+                                      "kind": "tuple"
+                                    },
+                                    {
+                                      "kind": "expression_list"
+                                    }
+                                  ]
+                                }
+                              ],
+                              "has": {
+                                "stopBy": "neighbor",
+                                "matches": "auto-call"
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              }
+            }
+          },
+          "rule": {
+            "all": [
+              {
+                "matches": {
+                  "member": {
+                    "X": "$V"
+                  }
+                }
+              },
+              {
+                "count": {
+                  "follows": {
+                    "stopBy": "end",
+                    "matches": {
+                      "member": {
+                        "X": "$U"
+                      }
+                    },
+                    "compare": {
+                      "left": "U",
+                      "op": "eq",
+                      "right": "V",
+                      "text": "structure"
+                    }
+                  },
+                  "min": 1
+                }
+              }
+            ],
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "block",
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "class_definition",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "argument_list",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "enum-base"
+                  }
+                }
+              }
+            }
+          },
+          "file": {
+            "path": {
+              "regex": "\\.py$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE796",
+        "message": "Enum contains duplicate value: `$V`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE796"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "non-unique-enums-stub",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "member": {
+              "params": [
+                "X"
+              ],
+              "rule": {
+                "kind": "expression_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "assignment",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "regex": "^:$"
+                    }
+                  },
+                  "has": {
+                    "stopBy": {
+                      "not": {
+                        "kind": "assignment"
+                      }
+                    },
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "^=$"
+                    },
+                    "not": {
+                      "kind": "assignment"
+                    },
+                    "pattern": "$X",
+                    "all": [
+                      {
+                        "not": {
+                          "any": [
+                            {
+                              "any": [
+                                {
+                                  "matches": "auto-call"
+                                },
+                                {
+                                  "any": [
+                                    {
+                                      "any": [
+                                        {
+                                          "kind": "tuple"
+                                        },
+                                        {
+                                          "kind": "expression_list"
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  "has": {
+                                    "stopBy": "neighbor",
+                                    "matches": "auto-call"
+                                  }
+                                }
+                              ]
+                            },
+                            {
+                              "matches": "unknown-value"
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "typing-cast": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute"
+                }
+              ],
+              "resolves": {
+                "import": [
+                  "typing.cast",
+                  "typing_extensions.cast",
+                  "_typeshed.cast"
+                ]
+              }
+            },
+            "ellipsis": {
+              "any": [
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "ellipsis"
+                  }
+                }
+              ]
+            },
+            "unknown-value": {
+              "any": [
+                {
+                  "matches": "ellipsis"
+                },
+                {
+                  "matches": "cast-ellipsis"
+                }
+              ]
+            },
+            "cast-ellipsis": {
+              "any": [
+                {
+                  "kind": "call",
+                  "all": [
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "not": {
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "(?s)."
+                          }
+                        },
+                        "matches": "typing-cast"
+                      }
+                    },
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "argument_list",
+                        "count": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "not": {
+                              "regex": "^[(),]$"
+                            }
+                          },
+                          "min": 2,
+                          "max": 2
+                        },
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "any": [
+                              {
+                                "kind": "keyword_argument"
+                              },
+                              {
+                                "kind": "dictionary_splat"
+                              }
+                            ]
+                          }
+                        },
+                        "has": {
+                          "stopBy": "neighbor",
+                          "matches": "ellipsis",
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "^,$"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "cast-ellipsis"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "all": [
+              {
+                "matches": {
+                  "member": {
+                    "X": "$V"
+                  }
+                }
+              },
+              {
+                "count": {
+                  "follows": {
+                    "stopBy": "end",
+                    "matches": {
+                      "member": {
+                        "X": "$U"
+                      }
+                    },
+                    "compare": {
+                      "left": "U",
+                      "op": "eq",
+                      "right": "V",
+                      "text": "structure"
+                    }
+                  },
+                  "min": 1
+                }
+              }
+            ],
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "block",
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "class_definition",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "argument_list",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "enum-base"
+                  }
+                }
+              }
+            }
+          },
+          "file": {
+            "path": {
+              "regex": "\\.pyi$"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE796",
+        "message": "Enum contains duplicate value: `$V`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE796"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-pie800-unnecessary-spread.json

@@ -0,0 +1,62 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie800-unnecessary-spread",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE800 (unnecessary-spread): a dict display spread with `**` into another dict display, reported on the inner dict (inside any parentheses).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unnecessary-spread",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "spread-slot": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "dictionary_splat",
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "dictionary"
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "spread-slot"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "dictionary",
+            "matches": "spread-slot"
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE800",
+        "message": "Unnecessary spread `**`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE800"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-pie804-unnecessary-dict-kwargs.json

@@ -0,0 +1,179 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie804-unnecessary-dict-kwargs",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE804 (unnecessary-dict-kwargs): a call argument `**{...}` whose dict display is a single `**x` spread, empty, or has only keys that are str literals (not bytes, f- or t-strings; escapes decoded, implicit concatenations joined) whose value is a Python identifier (not a keyword). Reported on the `**` argument.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unnecessary-dict-kwargs",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "kwarg-string": {
+              "any": [
+                {
+                  "kind": "string",
+                  "regex": "^[uUrR]{0,2}['\"]"
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "string",
+                      "not": {
+                        "regex": "^[uUrR]{0,2}['\"]"
+                      }
+                    }
+                  }
+                }
+              ],
+              "value": {
+                "regex": "^[\\p{XID_Start}_]\\p{XID_Continue}*$"
+              },
+              "not": {
+                "value": {
+                  "regex": "^(False|None|True|and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)$"
+                }
+              }
+            },
+            "kwarg-key": {
+              "any": [
+                {
+                  "matches": "kwarg-string"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "kwarg-key"
+                  }
+                }
+              ]
+            },
+            "spread-dict": {
+              "any": [
+                {
+                  "kind": "dictionary",
+                  "any": [
+                    {
+                      "count": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "regex": "^[{},]$"
+                              },
+                              {
+                                "any": [
+                                  {
+                                    "kind": "comment"
+                                  },
+                                  {
+                                    "kind": "line_continuation"
+                                  }
+                                ]
+                              }
+                            ]
+                          }
+                        },
+                        "min": 1,
+                        "max": 1
+                      },
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "dictionary_splat"
+                      }
+                    },
+                    {
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "all": [
+                            {
+                              "not": {
+                                "any": [
+                                  {
+                                    "regex": "^[{},]$"
+                                  },
+                                  {
+                                    "any": [
+                                      {
+                                        "kind": "comment"
+                                      },
+                                      {
+                                        "kind": "line_continuation"
+                                      }
+                                    ]
+                                  }
+                                ]
+                              }
+                            },
+                            {
+                              "not": {
+                                "kind": "pair",
+                                "has": {
+                                  "stopBy": "neighbor",
+                                  "not": {
+                                    "follows": {
+                                      "stopBy": "neighbor",
+                                      "regex": "(?s)."
+                                    }
+                                  },
+                                  "matches": "kwarg-key"
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "spread-dict"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "dictionary_splat",
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "argument_list"
+            },
+            "has": {
+              "stopBy": "neighbor",
+              "matches": "spread-dict"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE804",
+        "message": "Unnecessary `dict` kwargs",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE804"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}