npm - @neralabs/rerail-pack-python - Versions diffs - 0.1.1 - Mend

@neralabs/rerail-pack-python 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (147) hide show

package/LICENSE +202 -0
package/NOTICE +7 -0
package/README.md +36 -0
package/licenses/bandit/LICENSE +175 -0
package/licenses/bandit/UPSTREAM.md +100 -0
package/licenses/ruff/LICENSE +430 -0
package/licenses/ruff/UPSTREAM.md +338 -0
package/pack.json +912 -0
package/package.json +30 -0
package/rules/bandit-b101-assert-used.json +38 -0
package/rules/bandit-b102-exec-used.json +125 -0
package/rules/bandit-b110-try-except-pass.json +109 -0
package/rules/bandit-b112-try-except-continue.json +109 -0
package/rules/bandit-b113-request-without-timeout.json +138 -0
package/rules/bandit-b301-pickle.json +58 -0
package/rules/bandit-b302-marshal.json +48 -0
package/rules/bandit-b303-md5.json +79 -0
package/rules/bandit-b305-cipher-modes.json +47 -0
package/rules/bandit-b306-mktemp-q.json +54 -0
package/rules/bandit-b307-eval.json +125 -0
package/rules/bandit-b308-mark-safe.json +47 -0
package/rules/bandit-b310-urllib-urlopen.json +54 -0
package/rules/bandit-b311-random.json +57 -0
package/rules/bandit-b312-telnetlib.json +47 -0
package/rules/bandit-b313-xml-bad-celementtree.json +50 -0
package/rules/bandit-b314-xml-bad-elementtree.json +50 -0
package/rules/bandit-b315-xml-bad-expatreader.json +47 -0
package/rules/bandit-b316-xml-bad-expatbuilder.json +48 -0
package/rules/bandit-b317-xml-bad-sax.json +58 -0
package/rules/bandit-b318-xml-bad-minidom.json +48 -0
package/rules/bandit-b319-xml-bad-pulldom.json +48 -0
package/rules/bandit-b321-ftplib.json +47 -0
package/rules/bandit-b323-unverified-context.json +47 -0
package/rules/bandit-b401-import-telnetlib.json +48 -0
package/rules/bandit-b402-import-ftplib.json +48 -0
package/rules/bandit-b405-import-xml-etree.json +69 -0
package/rules/bandit-b406-import-xml-sax.json +73 -0
package/rules/bandit-b407-import-xml-expat.json +54 -0
package/rules/bandit-b408-import-xml-minidom.json +54 -0
package/rules/bandit-b409-import-xml-pulldom.json +54 -0
package/rules/bandit-b411-import-xmlrpclib.json +48 -0
package/rules/bandit-b413-import-pycrypto.json +159 -0
package/rules/bandit-b415-import-pyghmi.json +48 -0
package/rules/bandit-b502-ssl-with-bad-version.json +90 -0
package/rules/bandit-b505-weak-cryptographic-key.json +166 -0
package/rules/bandit-b507-ssh-no-host-key-verification.json +210 -0
package/rules/bandit-b606-start-process-with-no-shell.json +63 -0
package/rules/bandit-b610-django-extra-used.json +268 -0
package/rules/bandit-b615-huggingface-unsafe-download.json +1152 -0
package/rules/ruff-async100-cancel-scope-no-checkpoint.json +357 -0
package/rules/ruff-async105-trio-sync-call.json +199 -0
package/rules/ruff-async115-async-zero-sleep.json +264 -0
package/rules/ruff-async116-long-sleep-not-forever.json +267 -0
package/rules/ruff-async210-blocking-http-call-in-async-function.json +161 -0
package/rules/ruff-async221-run-process-in-async-function.json +342 -0
package/rules/ruff-async222-wait-for-process-in-async-function.json +144 -0
package/rules/ruff-async230-blocking-open-call-in-async-function.json +339 -0
package/rules/ruff-async250-blocking-input-in-async-function.json +143 -0
package/rules/ruff-async251-blocking-sleep-in-async-function.json +140 -0
package/rules/ruff-b002-unary-prefix-increment-decrement.json +54 -0
package/rules/ruff-b003-assignment-to-os-environ.json +54 -0
package/rules/ruff-b004-unreliable-callable-check.json +171 -0
package/rules/ruff-b005-strip-with-multi-characters.json +131 -0
package/rules/ruff-b007-unused-loop-control-variable.json +368 -0
package/rules/ruff-b009-get-attr-with-constant.json +190 -0
package/rules/ruff-b010-set-attr-with-constant.json +219 -0
package/rules/ruff-b011-assert-false.json +62 -0
package/rules/ruff-b013-redundant-tuple-in-exception-handler.json +94 -0
package/rules/ruff-b014-duplicate-handler-exception.json +126 -0
package/rules/ruff-b016-raise-literal.json +47 -0
package/rules/ruff-b020-loop-variable-overrides-iterator.json +341 -0
package/rules/ruff-b021-f-string-docstring.json +48 -0
package/rules/ruff-b022-useless-contextlib-suppress.json +95 -0
package/rules/ruff-b023-function-uses-loop-variable.json +560 -0
package/rules/ruff-b025-duplicate-try-block-exception.json +182 -0
package/rules/ruff-b026-star-arg-unpacking-after-keyword-arg.json +57 -0
package/rules/ruff-b028-no-explicit-stacklevel.json +177 -0
package/rules/ruff-b029-except-with-empty-tuple.json +102 -0
package/rules/ruff-b032-unintentional-type-annotation.json +157 -0
package/rules/ruff-b033-duplicate-value.json +129 -0
package/rules/ruff-b034-re-sub-positional-args.json +159 -0
package/rules/ruff-b039-mutable-contextvar-default.json +281 -0
package/rules/ruff-b904-raise-without-from-inside-except.json +194 -0
package/rules/ruff-b905-zip-without-explicit-strict.json +429 -0
package/rules/ruff-e711-none-comparison.json +199 -0
package/rules/ruff-e721-type-comparison.json +293 -0
package/rules/ruff-e722-bare-except.json +57 -0
package/rules/ruff-e742-ambiguous-class-name.json +47 -0
package/rules/ruff-e743-ambiguous-function-name.json +47 -0
package/rules/ruff-f403-undefined-local-with-import-star.json +73 -0
package/rules/ruff-f405-undefined-local-with-import-star-usage.json +87 -0
package/rules/ruff-f406-undefined-local-with-nested-import-star-usage.json +39 -0
package/rules/ruff-f407-future-feature-not-defined.json +56 -0
package/rules/ruff-f501-percent-format-invalid-format.json +88 -0
package/rules/ruff-f502-percent-format-expected-mapping.json +127 -0
package/rules/ruff-f503-percent-format-expected-sequence.json +127 -0
package/rules/ruff-f504-percent-format-extra-named-arguments.json +46 -0
package/rules/ruff-f505-percent-format-missing-argument.json +49 -0
package/rules/ruff-f506-percent-format-mixed-positional-and-named.json +114 -0
package/rules/ruff-f507-percent-format-positional-count-mismatch.json +78 -0
package/rules/ruff-f508-percent-format-star-requires-sequence.json +112 -0
package/rules/ruff-f509-percent-format-unsupported-format-character.json +86 -0
package/rules/ruff-f521-string-dot-format-invalid-format.json +83 -0
package/rules/ruff-f522-string-dot-format-extra-named-arguments.json +46 -0
package/rules/ruff-f523-string-dot-format-extra-positional-arguments.json +48 -0
package/rules/ruff-f524-string-dot-format-missing-arguments.json +46 -0
package/rules/ruff-f525-string-dot-format-mixing-automatic.json +99 -0
package/rules/ruff-f541-f-string-missing-placeholders.json +52 -0
package/rules/ruff-f601-multi-value-repeated-key-literal.json +215 -0
package/rules/ruff-f602-multi-value-repeated-key-variable.json +123 -0
package/rules/ruff-f622-multiple-starred-expressions.json +57 -0
package/rules/ruff-f632-is-literal.json +232 -0
package/rules/ruff-f633-invalid-print-syntax.json +299 -0
package/rules/ruff-f701-break-outside-loop.json +64 -0
package/rules/ruff-f702-continue-outside-loop.json +64 -0
package/rules/ruff-f706-return-outside-function.json +61 -0
package/rules/ruff-f707-default-except-not-last.json +50 -0
package/rules/ruff-f722-forward-annotation-syntax-error.json +654 -0
package/rules/ruff-f822-undefined-export.json +55 -0
package/rules/ruff-f823-undefined-local.json +42 -0
package/rules/ruff-f842-unused-annotation.json +51 -0
package/rules/ruff-f901-raise-not-implemented.json +97 -0
package/rules/ruff-pie794-duplicate-class-field-definition.json +157 -0
package/rules/ruff-pie796-non-unique-enums.json +460 -0
package/rules/ruff-pie800-unnecessary-spread.json +62 -0
package/rules/ruff-pie804-unnecessary-dict-kwargs.json +179 -0
package/rules/ruff-pie807-reimplemented-container-builtin.json +100 -0
package/rules/ruff-pie810-multiple-starts-ends-with.json +585 -0
package/rules/ruff-ret501-unnecessary-return-none.json +256 -0
package/rules/ruff-ret502-implicit-return-value.json +163 -0
package/rules/ruff-ret505-superfluous-else-return.json +211 -0
package/rules/ruff-ret506-superfluous-else-raise.json +211 -0
package/rules/ruff-ret507-superfluous-else-continue.json +211 -0
package/rules/ruff-ret508-superfluous-else-break.json +211 -0
package/rules/ruff-sim101-duplicate-isinstance-call.json +384 -0
package/rules/ruff-sim107-return-in-try-except-finally.json +82 -0
package/rules/ruff-sim109-compare-with-tuple.json +205 -0
package/rules/ruff-sim112-uncapitalized-environment-variables.json +168 -0
package/rules/ruff-sim113-enumerate-for-loop.json +562 -0
package/rules/ruff-sim208-double-negation.json +58 -0
package/rules/ruff-sim210-if-expr-with-true-false.json +90 -0
package/rules/ruff-sim211-if-expr-with-false-true.json +90 -0
package/rules/ruff-sim212-if-expr-with-twisted-arms.json +95 -0
package/rules/ruff-sim300-yoda-conditions.json +487 -0
package/rules/ruff-sim905-split-static-string.json +579 -0
package/rules/ruff-sim910-dict-get-with-none-default.json +518 -0
package/rules/ruff-t100-debugger.json +197 -0

package/rules/ruff-ret506-superfluous-else-raise.json ADDED Viewed

@@ -0,0 +1,211 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret506-superfluous-else-raise",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET506 (superfluous-else-raise): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `raise` statement and no earlier direct return/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "superfluous-else-raise",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            }
+          },
+          "rule": {
+            "regex": "^(?<BRANCH>elif|else)$",
+            "inside": {
+              "stopBy": "neighbor",
+              "any": [
+                {
+                  "kind": "elif_clause"
+                },
+                {
+                  "kind": "else_clause"
+                }
+              ],
+              "not": {
+                "follows": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "elif_clause"
+                    },
+                    {
+                      "kind": "else_clause"
+                    }
+                  ]
+                }
+              },
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "if_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "block",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "raise_statement",
+                    "not": {
+                      "follows": {
+                        "stopBy": "end",
+                        "any": [
+                          {
+                            "kind": "return_statement"
+                          },
+                          {
+                            "kind": "continue_statement"
+                          },
+                          {
+                            "kind": "break_statement"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                "inside": {
+                  "stopBy": {
+                    "any": [
+                      {
+                        "kind": "function_definition"
+                      },
+                      {
+                        "kind": "class_definition"
+                      }
+                    ]
+                  },
+                  "kind": "function_definition",
+                  "all": [
+                    {
+                      "matches": "analysed-function"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET506",
+        "message": "Unnecessary `$BRANCH` after `raise` statement",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET506"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-ret507-superfluous-else-continue.json ADDED Viewed

@@ -0,0 +1,211 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret507-superfluous-else-continue",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET507 (superfluous-else-continue): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `continue` statement and no earlier direct return/raise/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "superfluous-else-continue",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            }
+          },
+          "rule": {
+            "regex": "^(?<BRANCH>elif|else)$",
+            "inside": {
+              "stopBy": "neighbor",
+              "any": [
+                {
+                  "kind": "elif_clause"
+                },
+                {
+                  "kind": "else_clause"
+                }
+              ],
+              "not": {
+                "follows": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "elif_clause"
+                    },
+                    {
+                      "kind": "else_clause"
+                    }
+                  ]
+                }
+              },
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "if_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "block",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "continue_statement",
+                    "not": {
+                      "follows": {
+                        "stopBy": "end",
+                        "any": [
+                          {
+                            "kind": "return_statement"
+                          },
+                          {
+                            "kind": "raise_statement"
+                          },
+                          {
+                            "kind": "break_statement"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                "inside": {
+                  "stopBy": {
+                    "any": [
+                      {
+                        "kind": "function_definition"
+                      },
+                      {
+                        "kind": "class_definition"
+                      }
+                    ]
+                  },
+                  "kind": "function_definition",
+                  "all": [
+                    {
+                      "matches": "analysed-function"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET507",
+        "message": "Unnecessary `$BRANCH` after `continue` statement",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET507"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-ret508-superfluous-else-break.json ADDED Viewed

@@ -0,0 +1,211 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret508-superfluous-else-break",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET508 (superfluous-else-break): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `break` statement and no earlier direct return/raise/continue statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "superfluous-else-break",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            }
+          },
+          "rule": {
+            "regex": "^(?<BRANCH>elif|else)$",
+            "inside": {
+              "stopBy": "neighbor",
+              "any": [
+                {
+                  "kind": "elif_clause"
+                },
+                {
+                  "kind": "else_clause"
+                }
+              ],
+              "not": {
+                "follows": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "elif_clause"
+                    },
+                    {
+                      "kind": "else_clause"
+                    }
+                  ]
+                }
+              },
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "if_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "block",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "break_statement",
+                    "not": {
+                      "follows": {
+                        "stopBy": "end",
+                        "any": [
+                          {
+                            "kind": "return_statement"
+                          },
+                          {
+                            "kind": "raise_statement"
+                          },
+                          {
+                            "kind": "continue_statement"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                "inside": {
+                  "stopBy": {
+                    "any": [
+                      {
+                        "kind": "function_definition"
+                      },
+                      {
+                        "kind": "class_definition"
+                      }
+                    ]
+                  },
+                  "kind": "function_definition",
+                  "all": [
+                    {
+                      "matches": "analysed-function"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET508",
+        "message": "Unnecessary `$BRANCH` after `break` statement",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET508"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}