ruff.schema.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Options",
  "type": "object",
  "properties": {
    "allowed-confusables": {
      "description": "A list of allowed \"confusable\" Unicode characters to ignore when enforcing `RUF001`, `RUF002`, and `RUF003`.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string",
        "maxLength": 1,
        "minLength": 1
      }
    },
    "builtins": {
      "description": "A list of builtins to treat as defined references, in addition to the system builtins.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "cache-dir": {
      "description": "A path to the cache directory.\n\nBy default, Ruff stores cache results in a `.ruff_cache` directory in the current project root.\n\nHowever, Ruff will also respect the `RUFF_CACHE_DIR` environment variable, which takes precedence over that default.\n\nThis setting will override even the `RUFF_CACHE_DIR` environment variable, if set.",
      "type": [
        "string",
        "null"
      ]
    },
    "dummy-variable-rgx": {
      "description": "A regular expression used to identify \"dummy\" variables, or those which should be ignored when enforcing (e.g.) unused-variable rules. The default expression matches `_`, `__`, and `_var`, but not `_var_`.",
      "type": [
        "string",
        "null"
      ]
    },
    "exclude": {
      "description": "A list of file patterns to exclude from linting.\n\nExclusions are based on globs, and can be either:\n\n- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ). - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py` (to exclude any Python files in `directory`). Note that these paths are relative to the project root (e.g., the directory containing your `pyproject.toml`).\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).\n\nNote that you'll typically want to use [`extend-exclude`](#extend-exclude) to modify the excluded paths.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "extend": {
      "description": "A path to a local `pyproject.toml` file to merge into this configuration. User home directory and environment variables will be expanded.\n\nTo resolve the current `pyproject.toml` file, Ruff will first resolve this base configuration file, then merge in any properties defined in the current configuration file.",
      "type": [
        "string",
        "null"
      ]
    },
    "extend-exclude": {
      "description": "A list of file patterns to omit from linting, in addition to those specified by `exclude`.\n\nExclusions are based on globs, and can be either:\n\n- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ). - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py` (to exclude any Python files in `directory`). Note that these paths are relative to the project root (e.g., the directory containing your `pyproject.toml`).\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "extend-fixable": {
      "description": "A list of rule codes or prefixes to consider autofixable, in addition to those specified by `fixable`.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    },
    "extend-include": {
      "description": "A list of file patterns to include when linting, in addition to those specified by `include`.\n\nInclusion are based on globs, and should be single-path patterns, like `*.pyw`, to include any file with the `.pyw` extension.\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "extend-per-file-ignores": {
      "description": "A list of mappings from file pattern to rule codes or prefixes to exclude, in addition to any rules excluded by `per-file-ignores`.",
      "type": [
        "object",
        "null"
      ],
      "additionalProperties": {
        "type": "array",
        "items": {
          "$ref": "#/definitions/RuleSelector"
        }
      }
    },
    "extend-select": {
      "description": "A list of rule codes or prefixes to enable, in addition to those specified by `select`.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    },
    "external": {
      "description": "A list of rule codes that are unsupported by Ruff, but should be preserved when (e.g.) validating `# noqa` directives. Useful for retaining `# noqa` directives that cover plugins not yet implemented by Ruff.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "fix": {
      "description": "Enable autofix behavior by-default when running `ruff` (overridden by the `--fix` and `--no-fix` command-line flags).",
      "type": [
        "boolean",
        "null"
      ]
    },
    "fix-only": {
      "description": "Like `fix`, but disables reporting on leftover violation. Implies `fix`.",
      "type": [
        "boolean",
        "null"
      ]
    },
    "fixable": {
      "description": "A list of rule codes or prefixes to consider autofixable. By default, all rules are considered autofixable.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    },
    "flake8-annotations": {
      "description": "Options for the `flake8-annotations` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8AnnotationsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-bandit": {
      "description": "Options for the `flake8-bandit` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8BanditOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-bugbear": {
      "description": "Options for the `flake8-bugbear` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8BugbearOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-builtins": {
      "description": "Options for the `flake8-builtins` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8BuiltinsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-comprehensions": {
      "description": "Options for the `flake8-comprehensions` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8ComprehensionsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-errmsg": {
      "description": "Options for the `flake8-errmsg` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8ErrMsgOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-gettext": {
      "description": "Options for the `flake8-gettext` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8GetTextOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-implicit-str-concat": {
      "description": "Options for the `flake8-implicit-str-concat` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8ImplicitStrConcatOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-import-conventions": {
      "description": "Options for the `flake8-import-conventions` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8ImportConventionsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-pytest-style": {
      "description": "Options for the `flake8-pytest-style` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8PytestStyleOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-quotes": {
      "description": "Options for the `flake8-quotes` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8QuotesOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-self": {
      "description": "Options for the `flake8_self` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8SelfOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-tidy-imports": {
      "description": "Options for the `flake8-tidy-imports` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8TidyImportsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-type-checking": {
      "description": "Options for the `flake8-type-checking` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8TypeCheckingOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "flake8-unused-arguments": {
      "description": "Options for the `flake8-unused-arguments` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Flake8UnusedArgumentsOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "force-exclude": {
      "description": "Whether to enforce `exclude` and `extend-exclude` patterns, even for paths that are passed to Ruff explicitly. Typically, Ruff will lint any paths passed in directly, even if they would typically be excluded. Setting `force-exclude = true` will cause Ruff to respect these exclusions unequivocally.\n\nThis is useful for [`pre-commit`](https://pre-commit.com/), which explicitly passes all changed files to the [`ruff-pre-commit`](https://github.com/charliermarsh/ruff-pre-commit) plugin, regardless of whether they're marked as excluded by Ruff's own settings.",
      "type": [
        "boolean",
        "null"
      ]
    },
    "format": {
      "description": "The style in which violation messages should be formatted: `\"text\"` (default), `\"grouped\"` (group messages by file), `\"json\"` (machine-readable), `\"junit\"` (machine-readable XML), `\"github\"` (GitHub Actions annotations), `\"gitlab\"` (GitLab CI code quality report), `\"pylint\"` (Pylint text format) or `\"azure\"` (Azure Pipeline logging commands).",
      "anyOf": [
        {
          "$ref": "#/definitions/SerializationFormat"
        },
        {
          "type": "null"
        }
      ]
    },
    "ignore": {
      "description": "A list of rule codes or prefixes to ignore. Prefixes can specify exact rules (like `F841`), entire categories (like `F`), or anything in between.\n\nWhen breaking ties between enabled and disabled rules (via `select` and `ignore`, respectively), more specific prefixes override less specific prefixes.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    },
    "ignore-init-module-imports": {
      "description": "Avoid automatically removing unused imports in `__init__.py` files. Such imports will still be flagged, but with a dedicated message suggesting that the import is either added to the module's `__all__` symbol, or re-exported with a redundant alias (e.g., `import os as os`).",
      "type": [
        "boolean",
        "null"
      ]
    },
    "include": {
      "description": "A list of file patterns to include when linting.\n\nInclusion are based on globs, and should be single-path patterns, like `*.pyw`, to include any file with the `.pyw` extension.\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "isort": {
      "description": "Options for the `isort` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/IsortOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "line-length": {
      "description": "The line length to use when enforcing long-lines violations (like `E501`).",
      "type": [
        "integer",
        "null"
      ],
      "format": "uint",
      "minimum": 0.0
    },
    "mccabe": {
      "description": "Options for the `mccabe` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/McCabeOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "namespace-packages": {
      "description": "Mark the specified directories as namespace packages. For the purpose of module resolution, Ruff will treat those directories as if they contained an `__init__.py` file.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "pep8-naming": {
      "description": "Options for the `pep8-naming` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Pep8NamingOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "per-file-ignores": {
      "description": "A list of mappings from file pattern to rule codes or prefixes to exclude, when considering any matching files.",
      "type": [
        "object",
        "null"
      ],
      "additionalProperties": {
        "type": "array",
        "items": {
          "$ref": "#/definitions/RuleSelector"
        }
      }
    },
    "pycodestyle": {
      "description": "Options for the `pycodestyle` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Pycodestyle"
        },
        {
          "type": "null"
        }
      ]
    },
    "pydocstyle": {
      "description": "Options for the `pydocstyle` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/Pydocstyle"
        },
        {
          "type": "null"
        }
      ]
    },
    "pylint": {
      "description": "Options for the `pylint` plugin.",
      "anyOf": [
        {
          "$ref": "#/definitions/PylintOptions"
        },
        {
          "type": "null"
        }
      ]
    },
    "required-version": {
      "description": "Require a specific version of Ruff to be running (useful for unifying results across many environments, e.g., with a `pyproject.toml` file).",
      "anyOf": [
        {
          "$ref": "#/definitions/Version"
        },
        {
          "type": "null"
        }
      ]
    },
    "respect-gitignore": {
      "description": "Whether to automatically exclude files that are ignored by `.ignore`, `.gitignore`, `.git/info/exclude`, and global `gitignore` files. Enabled by default.",
      "type": [
        "boolean",
        "null"
      ]
    },
    "select": {
      "description": "A list of rule codes or prefixes to enable. Prefixes can specify exact rules (like `F841`), entire categories (like `F`), or anything in between.\n\nWhen breaking ties between enabled and disabled rules (via `select` and `ignore`, respectively), more specific prefixes override less specific prefixes.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    },
    "show-fixes": {
      "description": "Whether to show an enumeration of all autofixed lint violations (overridden by the `--show-fixes` command-line flag).",
      "type": [
        "boolean",
        "null"
      ]
    },
    "show-source": {
      "description": "Whether to show source code snippets when reporting lint violations (overridden by the `--show-source` command-line flag).",
      "type": [
        "boolean",
        "null"
      ]
    },
    "src": {
      "description": "The source code paths to consider, e.g., when resolving first- vs. third-party imports.\n\nAs an example: given a Python package structure like:\n\n```text my_package/ pyproject.toml src/ my_package/ __init__.py foo.py bar.py ```\n\nThe `src` directory should be included in the `src` option (e.g., `src = [\"src\"]`), such that when resolving imports, `my_package.foo` is considered a first-party import.\n\nThis field supports globs. For example, if you have a series of Python packages in a `python_modules` directory, `src = [\"python_modules/*\"]` would expand to incorporate all of the packages in that directory. User home directory and environment variables will also be expanded.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "target-version": {
      "description": "The Python version to target, e.g., when considering automatic code upgrades, like rewriting type annotations.\n\nIf omitted, the target version will be inferred from the `project.requires-python` field in the relevant `pyproject.toml` (e.g., `requires-python = \">=3.8\"`), if present.",
      "anyOf": [
        {
          "$ref": "#/definitions/PythonVersion"
        },
        {
          "type": "null"
        }
      ]
    },
    "task-tags": {
      "description": "A list of task tags to recognize (e.g., \"TODO\", \"FIXME\", \"XXX\").\n\nComments starting with these tags will be ignored by commented-out code detection (`ERA`), and skipped by line-length rules (`E501`) if `ignore-overlong-task-comments` is set to `true`.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "typing-modules": {
      "description": "A list of modules whose imports should be treated equivalently to members of the `typing` module.\n\nThis is useful for ensuring proper type annotation inference for projects that re-export `typing` and `typing_extensions` members from a compatibility module. If omitted, any members imported from modules apart from `typing` and `typing_extensions` will be treated as ordinary Python objects.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "type": "string"
      }
    },
    "unfixable": {
      "description": "A list of rule codes or prefixes to consider non-autofix-able.",
      "type": [
        "array",
        "null"
      ],
      "items": {
        "$ref": "#/definitions/RuleSelector"
      }
    }
  },
  "additionalProperties": false,
  "definitions": {
    "ApiBan": {
      "type": "object",
      "required": [
        "msg"
      ],
      "properties": {
        "msg": {
          "description": "The message to display when the API is used.",
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "ConstantType": {
      "type": "string",
      "enum": [
        "bytes",
        "complex",
        "float",
        "int",
        "str",
        "tuple"
      ]
    },
    "Convention": {
      "oneOf": [
        {
          "description": "Use Google-style docstrings.",
          "type": "string",
          "enum": [
            "google"
          ]
        },
        {
          "description": "Use NumPy-style docstrings.",
          "type": "string",
          "enum": [
            "numpy"
          ]
        },
        {
          "description": "Use PEP257-style docstrings.",
          "type": "string",
          "enum": [
            "pep257"
          ]
        }
      ]
    },
    "Flake8AnnotationsOptions": {
      "type": "object",
      "properties": {
        "allow-star-arg-any": {
          "description": "Whether to suppress `ANN401` for dynamically typed `*args` and `**kwargs` arguments.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "ignore-fully-untyped": {
          "description": "Whether to suppress `ANN*` rules for any declaration that hasn't been typed at all. This makes it easier to gradually add types to a codebase.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "mypy-init-return": {
          "description": "Whether to allow the omission of a return type hint for `__init__` if at least one argument is annotated.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "suppress-dummy-args": {
          "description": "Whether to suppress `ANN000`-level violations for arguments matching the \"dummy\" variable regex (like `_`).",
          "type": [
            "boolean",
            "null"
          ]
        },
        "suppress-none-returning": {
          "description": "Whether to suppress `ANN200`-level violations for functions that meet either of the following criteria:\n\n- Contain no `return` statement. - Explicit `return` statement(s) all return `None` (explicitly or implicitly).",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "Flake8BanditOptions": {
      "type": "object",
      "properties": {
        "check-typed-exception": {
          "description": "Whether to disallow `try`-`except`-`pass` (`S110`) for specific exception types. By default, `try`-`except`-`pass` is only disallowed for `Exception` and `BaseException`.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "hardcoded-tmp-directory": {
          "description": "A list of directories to consider temporary.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "hardcoded-tmp-directory-extend": {
          "description": "A list of directories to consider temporary, in addition to those specified by `hardcoded-tmp-directory`.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8BugbearOptions": {
      "type": "object",
      "properties": {
        "extend-immutable-calls": {
          "description": "Additional callable functions to consider \"immutable\" when evaluating, e.g., the `no-mutable-default-argument` rule (`B006`) or `no-function-call-in-dataclass-defaults` rule (`RUF009`).",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8BuiltinsOptions": {
      "type": "object",
      "properties": {
        "builtins-ignorelist": {
          "description": "Ignore list of builtins.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8ComprehensionsOptions": {
      "type": "object",
      "properties": {
        "allow-dict-calls-with-keyword-arguments": {
          "description": "Allow `dict` calls that make use of keyword arguments (e.g., `dict(a=1, b=2)`).",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "Flake8ErrMsgOptions": {
      "type": "object",
      "properties": {
        "max-string-length": {
          "description": "Maximum string length for string literals in exception messages.",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        }
      },
      "additionalProperties": false
    },
    "Flake8GetTextOptions": {
      "type": "object",
      "properties": {
        "extend-function-names": {
          "description": "Additional function names to consider as internationalization calls, in addition to those included in `function-names`.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "function-names": {
          "description": "The function names to consider as internationalization calls.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8ImplicitStrConcatOptions": {
      "type": "object",
      "properties": {
        "allow-multiline": {
          "description": "Whether to allow implicit string concatenations for multiline strings. By default, implicit concatenations of multiline strings are allowed (but continuation lines, delimited with a backslash, are prohibited).\n\nNote that setting `allow-multiline = false` should typically be coupled with disabling `explicit-string-concatenation` (`ISC003`). Otherwise, both explicit and implicit multiline string concatenations will be seen as violations.",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "Flake8ImportConventionsOptions": {
      "type": "object",
      "properties": {
        "aliases": {
          "description": "The conventional aliases for imports. These aliases can be extended by the `extend_aliases` option.",
          "type": [
            "object",
            "null"
          ],
          "additionalProperties": {
            "type": "string"
          }
        },
        "banned-aliases": {
          "description": "A mapping from module to its banned import aliases.",
          "type": [
            "object",
            "null"
          ],
          "additionalProperties": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "banned-from": {
          "description": "A list of modules that are allowed to be imported from",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          },
          "uniqueItems": true
        },
        "extend-aliases": {
          "description": "A mapping from module to conventional import alias. These aliases will be added to the `aliases` mapping.",
          "type": [
            "object",
            "null"
          ],
          "additionalProperties": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8PytestStyleOptions": {
      "type": "object",
      "properties": {
        "fixture-parentheses": {
          "description": "Boolean flag specifying whether `@pytest.fixture()` without parameters should have parentheses. If the option is set to `true` (the default), `@pytest.fixture()` is valid and `@pytest.fixture` is invalid. If set to `false`, `@pytest.fixture` is valid and `@pytest.fixture()` is invalid.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "mark-parentheses": {
          "description": "Boolean flag specifying whether `@pytest.mark.foo()` without parameters should have parentheses. If the option is set to `true` (the default), `@pytest.mark.foo()` is valid and `@pytest.mark.foo` is invalid. If set to `false`, `@pytest.fixture` is valid and `@pytest.mark.foo()` is invalid.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "parametrize-names-type": {
          "description": "Expected type for multiple argument names in `@pytest.mark.parametrize`. The following values are supported:\n\n- `csv` — a comma-separated list, e.g. `@pytest.mark.parametrize('name1,name2', ...)` - `tuple` (default) — e.g. `@pytest.mark.parametrize(('name1', 'name2'), ...)` - `list` — e.g. `@pytest.mark.parametrize(['name1', 'name2'], ...)`",
          "anyOf": [
            {
              "$ref": "#/definitions/ParametrizeNameType"
            },
            {
              "type": "null"
            }
          ]
        },
        "parametrize-values-row-type": {
          "description": "Expected type for each row of values in `@pytest.mark.parametrize` in case of multiple parameters. The following values are supported:\n\n- `tuple` (default) — e.g. `@pytest.mark.parametrize(('name1', 'name2'), [(1, 2), (3, 4)])` - `list` — e.g. `@pytest.mark.parametrize(('name1', 'name2'), [[1, 2], [3, 4]])`",
          "anyOf": [
            {
              "$ref": "#/definitions/ParametrizeValuesRowType"
            },
            {
              "type": "null"
            }
          ]
        },
        "parametrize-values-type": {
          "description": "Expected type for the list of values rows in `@pytest.mark.parametrize`. The following values are supported:\n\n- `tuple` — e.g. `@pytest.mark.parametrize('name', (1, 2, 3))` - `list` (default) — e.g. `@pytest.mark.parametrize('name', [1, 2, 3])`",
          "anyOf": [
            {
              "$ref": "#/definitions/ParametrizeValuesType"
            },
            {
              "type": "null"
            }
          ]
        },
        "raises-extend-require-match-for": {
          "description": "List of additional exception names that require a match= parameter in a `pytest.raises()` call. This extends the default list of exceptions that require a match= parameter. This option is useful if you want to extend the default list of exceptions that require a match= parameter without having to specify the entire list. Note that this option does not remove any exceptions from the default list.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "raises-require-match-for": {
          "description": "List of exception names that require a match= parameter in a `pytest.raises()` call.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8QuotesOptions": {
      "type": "object",
      "properties": {
        "avoid-escape": {
          "description": "Whether to avoid using single quotes if a string contains single quotes, or vice-versa with double quotes, as per [PEP 8](https://peps.python.org/pep-0008/#string-quotes). This minimizes the need to escape quotation marks within strings.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "docstring-quotes": {
          "description": "Quote style to prefer for docstrings (either \"single\" or \"double\").",
          "anyOf": [
            {
              "$ref": "#/definitions/Quote"
            },
            {
              "type": "null"
            }
          ]
        },
        "inline-quotes": {
          "description": "Quote style to prefer for inline strings (either \"single\" or \"double\").",
          "anyOf": [
            {
              "$ref": "#/definitions/Quote"
            },
            {
              "type": "null"
            }
          ]
        },
        "multiline-quotes": {
          "description": "Quote style to prefer for multiline strings (either \"single\" or \"double\").",
          "anyOf": [
            {
              "$ref": "#/definitions/Quote"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "additionalProperties": false
    },
    "Flake8SelfOptions": {
      "type": "object",
      "properties": {
        "ignore-names": {
          "description": "A list of names to ignore when considering `flake8-self` violations.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8TidyImportsOptions": {
      "type": "object",
      "properties": {
        "ban-relative-imports": {
          "description": "Whether to ban all relative imports (`\"all\"`), or only those imports that extend into the parent module or beyond (`\"parents\"`).",
          "anyOf": [
            {
              "$ref": "#/definitions/Strictness"
            },
            {
              "type": "null"
            }
          ]
        },
        "banned-api": {
          "description": "Specific modules or module members that may not be imported or accessed. Note that this rule is only meant to flag accidental uses, and can be circumvented via `eval` or `importlib`.",
          "type": [
            "object",
            "null"
          ],
          "additionalProperties": {
            "$ref": "#/definitions/ApiBan"
          }
        }
      },
      "additionalProperties": false
    },
    "Flake8TypeCheckingOptions": {
      "type": "object",
      "properties": {
        "exempt-modules": {
          "description": "Exempt certain modules from needing to be moved into type-checking blocks.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "runtime-evaluated-base-classes": {
          "description": "Exempt classes that list any of the enumerated classes as a base class from needing to be moved into type-checking blocks.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "runtime-evaluated-decorators": {
          "description": "Exempt classes decorated with any of the enumerated decorators from needing to be moved into type-checking blocks.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "strict": {
          "description": "Enforce TC001, TC002, and TC003 rules even when valid runtime imports are present for the same module. See flake8-type-checking's [strict](https://github.com/snok/flake8-type-checking#strict) option.",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "Flake8UnusedArgumentsOptions": {
      "type": "object",
      "properties": {
        "ignore-variadic-names": {
          "description": "Whether to allow unused variadic arguments, like `*args` and `**kwargs`.",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "ImportSection": {
      "anyOf": [
        {
          "$ref": "#/definitions/ImportType"
        },
        {
          "type": "string"
        }
      ]
    },
    "ImportType": {
      "type": "string",
      "enum": [
        "future",
        "standard-library",
        "third-party",
        "first-party",
        "local-folder"
      ]
    },
    "IsortOptions": {
      "type": "object",
      "properties": {
        "classes": {
          "description": "An override list of tokens to always recognize as a Class for `order-by-type` regardless of casing.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "combine-as-imports": {
          "description": "Combines as imports on the same line. See isort's [`combine-as-imports`](https://pycqa.github.io/isort/docs/configuration/options.html#combine-as-imports) option.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "constants": {
          "description": "An override list of tokens to always recognize as a CONSTANT for `order-by-type` regardless of casing.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "extra-standard-library": {
          "description": "A list of modules to consider standard-library, in addition to those known to Ruff in advance.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "force-single-line": {
          "description": "Forces all from imports to appear on their own line.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "force-sort-within-sections": {
          "description": "Don't sort straight-style imports (like `import sys`) before from-style imports (like `from itertools import groupby`). Instead, sort the imports by module, independent of import style.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "force-to-top": {
          "description": "Force specific imports to the top of their appropriate section.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "force-wrap-aliases": {
          "description": "Force `import from` statements with multiple members and at least one alias (e.g., `import A as B`) to wrap such that every line contains exactly one member. For example, this formatting would be retained, rather than condensing to a single line:\n\n```python from .utils import ( test_directory as test_directory, test_id as test_id ) ```\n\nNote that this setting is only effective when combined with `combine-as-imports = true`. When `combine-as-imports` isn't enabled, every aliased `import from` will be given its own line, in which case, wrapping is not necessary.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "forced-separate": {
          "description": "A list of modules to separate into auxiliary block(s) of imports, in the order specified.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "known-first-party": {
          "description": "A list of modules to consider first-party, regardless of whether they can be identified as such via introspection of the local filesystem.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "known-local-folder": {
          "description": "A list of modules to consider being a local folder. Generally, this is reserved for relative imports (`from . import module`).",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "known-third-party": {
          "description": "A list of modules to consider third-party, regardless of whether they can be identified as such via introspection of the local filesystem.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "lines-after-imports": {
          "description": "The number of blank lines to place after imports. Use `-1` for automatic determination.",
          "type": [
            "integer",
            "null"
          ],
          "format": "int"
        },
        "lines-between-types": {
          "description": "The number of lines to place between \"direct\" and `import from` imports.",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        },
        "no-lines-before": {
          "description": "A list of sections that should _not_ be delineated from the previous section via empty lines.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "$ref": "#/definitions/ImportSection"
          }
        },
        "order-by-type": {
          "description": "Order imports by type, which is determined by case, in addition to alphabetically.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "relative-imports-order": {
          "description": "Whether to place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local), or vice versa.\n\nThe default (\"furthest-to-closest\") is equivalent to isort's `reverse-relative` default (`reverse-relative = false`); setting this to \"closest-to-furthest\" is equivalent to isort's `reverse-relative = true`.",
          "anyOf": [
            {
              "$ref": "#/definitions/RelativeImportsOrder"
            },
            {
              "type": "null"
            }
          ]
        },
        "required-imports": {
          "description": "Add the specified import line to all files.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "section-order": {
          "description": "Override in which order the sections should be output. Can be used to move custom sections.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "$ref": "#/definitions/ImportSection"
          }
        },
        "sections": {
          "description": "A list of mappings from section names to modules. By default custom sections are output last, but this can be overridden with `section-order`.",
          "type": [
            "object",
            "null"
          ],
          "additionalProperties": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "single-line-exclusions": {
          "description": "One or more modules to exclude from the single line rule.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "split-on-trailing-comma": {
          "description": "If a comma is placed after the last member in a multi-line import, then the imports will never be folded into one line.\n\nSee isort's [`split-on-trailing-comma`](https://pycqa.github.io/isort/docs/configuration/options.html#split-on-trailing-comma) option.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "variables": {
          "description": "An override list of tokens to always recognize as a var for `order-by-type` regardless of casing.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "McCabeOptions": {
      "type": "object",
      "properties": {
        "max-complexity": {
          "description": "The maximum McCabe complexity to allow before triggering `C901` errors.",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        }
      },
      "additionalProperties": false
    },
    "ParametrizeNameType": {
      "type": "string",
      "enum": [
        "csv",
        "tuple",
        "list"
      ]
    },
    "ParametrizeValuesRowType": {
      "type": "string",
      "enum": [
        "tuple",
        "list"
      ]
    },
    "ParametrizeValuesType": {
      "type": "string",
      "enum": [
        "tuple",
        "list"
      ]
    },
    "Pep8NamingOptions": {
      "type": "object",
      "properties": {
        "classmethod-decorators": {
          "description": "A list of decorators that, when applied to a method, indicate that the method should be treated as a class method (in addition to the builtin `@classmethod`).\n\nFor example, Ruff will expect that any method decorated by a decorator in this list takes a `cls` argument as its first argument.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "ignore-names": {
          "description": "A list of names to ignore when considering `pep8-naming` violations.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "staticmethod-decorators": {
          "description": "A list of decorators that, when applied to a method, indicate that the method should be treated as a static method (in addition to the builtin `@staticmethod`).\n\nFor example, Ruff will expect that any method decorated by a decorator in this list has no `self` or `cls` argument.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "Pycodestyle": {
      "type": "object",
      "properties": {
        "ignore-overlong-task-comments": {
          "description": "Whether line-length violations (`E501`) should be triggered for comments starting with `task-tags` (by default: \\[\"TODO\", \"FIXME\", and \"XXX\"\\]).",
          "type": [
            "boolean",
            "null"
          ]
        },
        "max-doc-length": {
          "description": "The maximum line length to allow for line-length violations within documentation (`W505`), including standalone comments.",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        }
      },
      "additionalProperties": false
    },
    "Pydocstyle": {
      "type": "object",
      "properties": {
        "convention": {
          "description": "Whether to use Google-style or NumPy-style conventions or the PEP257 defaults when analyzing docstring sections.",
          "anyOf": [
            {
              "$ref": "#/definitions/Convention"
            },
            {
              "type": "null"
            }
          ]
        },
        "ignore-decorators": {
          "description": "Ignore docstrings for functions or methods decorated with the specified fully-qualified decorators.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        },
        "property-decorators": {
          "description": "A list of decorators that, when applied to a method, indicate that the method should be treated as a property (in addition to the builtin `@property` and standard-library `@functools.cached_property`).\n\nFor example, Ruff will expect that any method decorated by a decorator in this list can use a non-imperative summary line.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": false
    },
    "PylintOptions": {
      "type": "object",
      "properties": {
        "allow-magic-value-types": {
          "description": "Constant types to ignore when used as \"magic values\" (see: `PLR2004`).",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "$ref": "#/definitions/ConstantType"
          }
        },
        "max-args": {
          "description": "Maximum number of arguments allowed for a function or method definition (see: `PLR0913`).",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        },
        "max-branches": {
          "description": "Maximum number of branches allowed for a function or method body (see: `PLR0912`).",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        },
        "max-returns": {
          "description": "Maximum number of return statements allowed for a function or method body (see `PLR0911`)",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        },
        "max-statements": {
          "description": "Maximum number of statements allowed for a function or method body (see: `PLR0915`).",
          "type": [
            "integer",
            "null"
          ],
          "format": "uint",
          "minimum": 0.0
        }
      },
      "additionalProperties": false
    },
    "PythonVersion": {
      "type": "string",
      "enum": [
        "py37",
        "py38",
        "py39",
        "py310",
        "py311"
      ]
    },
    "Quote": {
      "oneOf": [
        {
          "description": "Use single quotes.",
          "type": "string",
          "enum": [
            "single"
          ]
        },
        {
          "description": "Use double quotes.",
          "type": "string",
          "enum": [
            "double"
          ]
        }
      ]
    },
    "RelativeImportsOrder": {
      "oneOf": [
        {
          "description": "Place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local).",
          "type": "string",
          "enum": [
            "closest-to-furthest"
          ]
        },
        {
          "description": "Place \"further\" imports (more `.` characters, least local) imports before \"closer\" imports (fewer `.` characters, most local).",
          "type": "string",
          "enum": [
            "furthest-to-closest"
          ]
        }
      ]
    },
    "RuleSelector": {
      "type": "string",
      "enum": [
        "A",
        "A0",
        "A00",
        "A001",
        "A002",
        "A003",
        "ALL",
        "ANN",
        "ANN0",
        "ANN00",
        "ANN001",
        "ANN002",
        "ANN003",
        "ANN1",
        "ANN10",
        "ANN101",
        "ANN102",
        "ANN2",
        "ANN20",
        "ANN201",
        "ANN202",
        "ANN204",
        "ANN205",
        "ANN206",
        "ANN4",
        "ANN40",
        "ANN401",
        "ARG",
        "ARG0",
        "ARG00",
        "ARG001",
        "ARG002",
        "ARG003",
        "ARG004",
        "ARG005",
        "ASYNC",
        "ASYNC1",
        "ASYNC10",
        "ASYNC100",
        "ASYNC101",
        "ASYNC102",
        "B",
        "B0",
        "B00",
        "B002",
        "B003",
        "B004",
        "B005",
        "B006",
        "B007",
        "B008",
        "B009",
        "B01",
        "B010",
        "B011",
        "B012",
        "B013",
        "B014",
        "B015",
        "B016",
        "B017",
        "B018",
        "B019",
        "B02",
        "B020",
        "B021",
        "B022",
        "B023",
        "B024",
        "B025",
        "B026",
        "B027",
        "B028",
        "B029",
        "B03",
        "B030",
        "B031",
        "B032",
        "B9",
        "B90",
        "B904",
        "B905",
        "BLE",
        "BLE0",
        "BLE00",
        "BLE001",
        "C",
        "C4",
        "C40",
        "C400",
        "C401",
        "C402",
        "C403",
        "C404",
        "C405",
        "C406",
        "C408",
        "C409",
        "C41",
        "C410",
        "C411",
        "C413",
        "C414",
        "C415",
        "C416",
        "C417",
        "C418",
        "C419",
        "C9",
        "C90",
        "C901",
        "COM",
        "COM8",
        "COM81",
        "COM812",
        "COM818",
        "COM819",
        "D",
        "D1",
        "D10",
        "D100",
        "D101",
        "D102",
        "D103",
        "D104",
        "D105",
        "D106",
        "D107",
        "D2",
        "D20",
        "D200",
        "D201",
        "D202",
        "D203",
        "D204",
        "D205",
        "D206",
        "D207",
        "D208",
        "D209",
        "D21",
        "D210",
        "D211",
        "D212",
        "D213",
        "D214",
        "D215",
        "D3",
        "D30",
        "D300",
        "D301",
        "D4",
        "D40",
        "D400",
        "D401",
        "D402",
        "D403",
        "D404",
        "D405",
        "D406",
        "D407",
        "D408",
        "D409",
        "D41",
        "D410",
        "D411",
        "D412",
        "D413",
        "D414",
        "D415",
        "D416",
        "D417",
        "D418",
        "D419",
        "DJ",
        "DJ0",
        "DJ00",
        "DJ001",
        "DJ003",
        "DJ006",
        "DJ007",
        "DJ008",
        "DJ01",
        "DJ012",
        "DJ013",
        "DTZ",
        "DTZ0",
        "DTZ00",
        "DTZ001",
        "DTZ002",
        "DTZ003",
        "DTZ004",
        "DTZ005",
        "DTZ006",
        "DTZ007",
        "DTZ01",
        "DTZ011",
        "DTZ012",
        "E",
        "E1",
        "E10",
        "E101",
        "E111",
        "E112",
        "E113",
        "E114",
        "E115",
        "E116",
        "E117",
        "E201",
        "E202",
        "E203",
        "E211",
        "E221",
        "E222",
        "E223",
        "E224",
        "E225",
        "E226",
        "E227",
        "E228",
        "E231",
        "E251",
        "E252",
        "E261",
        "E262",
        "E265",
        "E266",
        "E271",
        "E272",
        "E273",
        "E274",
        "E275",
        "E4",
        "E40",
        "E401",
        "E402",
        "E5",
        "E50",
        "E501",
        "E7",
        "E70",
        "E701",
        "E702",
        "E703",
        "E71",
        "E711",
        "E712",
        "E713",
        "E714",
        "E72",
        "E721",
        "E722",
        "E73",
        "E731",
        "E74",
        "E741",
        "E742",
        "E743",
        "E9",
        "E90",
        "E902",
        "E99",
        "E999",
        "EM",
        "EM1",
        "EM10",
        "EM101",
        "EM102",
        "EM103",
        "ERA",
        "ERA0",
        "ERA00",
        "ERA001",
        "EXE",
        "EXE0",
        "EXE00",
        "EXE001",
        "EXE002",
        "EXE003",
        "EXE004",
        "EXE005",
        "F",
        "F4",
        "F40",
        "F401",
        "F402",
        "F403",
        "F404",
        "F405",
        "F406",
        "F407",
        "F5",
        "F50",
        "F501",
        "F502",
        "F503",
        "F504",
        "F505",
        "F506",
        "F507",
        "F508",
        "F509",
        "F52",
        "F521",
        "F522",
        "F523",
        "F524",
        "F525",
        "F54",
        "F541",
        "F6",
        "F60",
        "F601",
        "F602",
        "F62",
        "F621",
        "F622",
        "F63",
        "F631",
        "F632",
        "F633",
        "F634",
        "F7",
        "F70",
        "F701",
        "F702",
        "F704",
        "F706",
        "F707",
        "F72",
        "F722",
        "F8",
        "F81",
        "F811",
        "F82",
        "F821",
        "F822",
        "F823",
        "F84",
        "F841",
        "F842",
        "F9",
        "F90",
        "F901",
        "FA",
        "FA1",
        "FA10",
        "FA100",
        "FBT",
        "FBT0",
        "FBT00",
        "FBT001",
        "FBT002",
        "FBT003",
        "FLY",
        "FLY0",
        "FLY00",
        "FLY002",
        "G",
        "G0",
        "G00",
        "G001",
        "G002",
        "G003",
        "G004",
        "G01",
        "G010",
        "G1",
        "G10",
        "G101",
        "G2",
        "G20",
        "G201",
        "G202",
        "I",
        "I0",
        "I00",
        "I001",
        "I002",
        "ICN",
        "ICN0",
        "ICN00",
        "ICN001",
        "ICN002",
        "ICN003",
        "INP",
        "INP0",
        "INP00",
        "INP001",
        "INT",
        "INT0",
        "INT00",
        "INT001",
        "INT002",
        "INT003",
        "ISC",
        "ISC0",
        "ISC00",
        "ISC001",
        "ISC002",
        "ISC003",
        "N",
        "N8",
        "N80",
        "N801",
        "N802",
        "N803",
        "N804",
        "N805",
        "N806",
        "N807",
        "N81",
        "N811",
        "N812",
        "N813",
        "N814",
        "N815",
        "N816",
        "N817",
        "N818",
        "N9",
        "N99",
        "N999",
        "NPY",
        "NPY0",
        "NPY00",
        "NPY001",
        "NPY002",
        "PD",
        "PD0",
        "PD00",
        "PD002",
        "PD003",
        "PD004",
        "PD007",
        "PD008",
        "PD009",
        "PD01",
        "PD010",
        "PD011",
        "PD012",
        "PD013",
        "PD015",
        "PD9",
        "PD90",
        "PD901",
        "PGH",
        "PGH0",
        "PGH00",
        "PGH001",
        "PGH002",
        "PGH003",
        "PGH004",
        "PGH005",
        "PIE",
        "PIE7",
        "PIE79",
        "PIE790",
        "PIE794",
        "PIE796",
        "PIE8",
        "PIE80",
        "PIE800",
        "PIE804",
        "PIE807",
        "PIE81",
        "PIE810",
        "PL",
        "PLC",
        "PLC0",
        "PLC04",
        "PLC041",
        "PLC0414",
        "PLC1",
        "PLC19",
        "PLC190",
        "PLC1901",
        "PLC3",
        "PLC30",
        "PLC300",
        "PLC3002",
        "PLE",
        "PLE0",
        "PLE01",
        "PLE010",
        "PLE0100",
        "PLE0101",
        "PLE011",
        "PLE0116",
        "PLE0117",
        "PLE0118",
        "PLE02",
        "PLE024",
        "PLE0241",
        "PLE03",
        "PLE030",
        "PLE0302",
        "PLE06",
        "PLE060",
        "PLE0604",
        "PLE0605",
        "PLE1",
        "PLE11",
        "PLE114",
        "PLE1142",
        "PLE12",
        "PLE120",
        "PLE1205",
        "PLE1206",
        "PLE13",
        "PLE130",
        "PLE1307",
        "PLE131",
        "PLE1310",
        "PLE15",
        "PLE150",
        "PLE1507",
        "PLE2",
        "PLE25",
        "PLE250",
        "PLE2502",
        "PLE251",
        "PLE2510",
        "PLE2512",
        "PLE2513",
        "PLE2514",
        "PLE2515",
        "PLR",
        "PLR0",
        "PLR01",
        "PLR013",
        "PLR0133",
        "PLR02",
        "PLR020",
        "PLR0206",
        "PLR04",
        "PLR040",
        "PLR0402",
        "PLR09",
        "PLR091",
        "PLR0911",
        "PLR0912",
        "PLR0913",
        "PLR0915",
        "PLR1",
        "PLR17",
        "PLR170",
        "PLR1701",
        "PLR171",
        "PLR1711",
        "PLR172",
        "PLR1722",
        "PLR2",
        "PLR20",
        "PLR200",
        "PLR2004",
        "PLR5",
        "PLR55",
        "PLR550",
        "PLR5501",
        "PLW",
        "PLW0",
        "PLW01",
        "PLW012",
        "PLW0120",
        "PLW0129",
        "PLW013",
        "PLW0130",
        "PLW0131",
        "PLW04",
        "PLW040",
        "PLW0406",
        "PLW06",
        "PLW060",
        "PLW0602",
        "PLW0603",
        "PLW07",
        "PLW071",
        "PLW0711",
        "PLW1",
        "PLW15",
        "PLW150",
        "PLW1508",
        "PLW2",
        "PLW29",
        "PLW290",
        "PLW2901",
        "PLW3",
        "PLW33",
        "PLW330",
        "PLW3301",
        "PT",
        "PT0",
        "PT00",
        "PT001",
        "PT002",
        "PT003",
        "PT004",
        "PT005",
        "PT006",
        "PT007",
        "PT008",
        "PT009",
        "PT01",
        "PT010",
        "PT011",
        "PT012",
        "PT013",
        "PT015",
        "PT016",
        "PT017",
        "PT018",
        "PT019",
        "PT02",
        "PT020",
        "PT021",
        "PT022",
        "PT023",
        "PT024",
        "PT025",
        "PT026",
        "PTH",
        "PTH1",
        "PTH10",
        "PTH100",
        "PTH101",
        "PTH102",
        "PTH103",
        "PTH104",
        "PTH105",
        "PTH106",
        "PTH107",
        "PTH108",
        "PTH109",
        "PTH11",
        "PTH110",
        "PTH111",
        "PTH112",
        "PTH113",
        "PTH114",
        "PTH115",
        "PTH116",
        "PTH117",
        "PTH118",
        "PTH119",
        "PTH12",
        "PTH120",
        "PTH121",
        "PTH122",
        "PTH123",
        "PTH124",
        "PYI",
        "PYI0",
        "PYI00",
        "PYI001",
        "PYI006",
        "PYI007",
        "PYI008",
        "PYI009",
        "PYI01",
        "PYI010",
        "PYI011",
        "PYI012",
        "PYI013",
        "PYI014",
        "PYI015",
        "PYI016",
        "PYI02",
        "PYI020",
        "PYI021",
        "PYI03",
        "PYI033",
        "PYI04",
        "PYI042",
        "PYI043",
        "PYI05",
        "PYI052",
        "Q",
        "Q0",
        "Q00",
        "Q000",
        "Q001",
        "Q002",
        "Q003",
        "RET",
        "RET5",
        "RET50",
        "RET501",
        "RET502",
        "RET503",
        "RET504",
        "RET505",
        "RET506",
        "RET507",
        "RET508",
        "RSE",
        "RSE1",
        "RSE10",
        "RSE102",
        "RUF",
        "RUF0",
        "RUF00",
        "RUF001",
        "RUF002",
        "RUF003",
        "RUF005",
        "RUF006",
        "RUF007",
        "RUF008",
        "RUF009",
        "RUF01",
        "RUF010",
        "RUF1",
        "RUF10",
        "RUF100",
        "S",
        "S1",
        "S10",
        "S101",
        "S102",
        "S103",
        "S104",
        "S105",
        "S106",
        "S107",
        "S108",
        "S11",
        "S110",
        "S112",
        "S113",
        "S3",
        "S30",
        "S301",
        "S302",
        "S303",
        "S304",
        "S305",
        "S306",
        "S307",
        "S308",
        "S31",
        "S310",
        "S311",
        "S312",
        "S313",
        "S314",
        "S315",
        "S316",
        "S317",
        "S318",
        "S319",
        "S32",
        "S320",
        "S321",
        "S323",
        "S324",
        "S5",
        "S50",
        "S501",
        "S506",
        "S508",
        "S509",
        "S6",
        "S60",
        "S601",
        "S602",
        "S603",
        "S604",
        "S605",
        "S606",
        "S607",
        "S608",
        "S61",
        "S612",
        "S7",
        "S70",
        "S701",
        "SIM",
        "SIM1",
        "SIM10",
        "SIM101",
        "SIM102",
        "SIM103",
        "SIM105",
        "SIM107",
        "SIM108",
        "SIM109",
        "SIM11",
        "SIM110",
        "SIM112",
        "SIM114",
        "SIM115",
        "SIM116",
        "SIM117",
        "SIM118",
        "SIM2",
        "SIM20",
        "SIM201",
        "SIM202",
        "SIM208",
        "SIM21",
        "SIM210",
        "SIM211",
        "SIM212",
        "SIM22",
        "SIM220",
        "SIM221",
        "SIM222",
        "SIM223",
        "SIM3",
        "SIM30",
        "SIM300",
        "SIM4",
        "SIM40",
        "SIM401",
        "SIM9",
        "SIM91",
        "SIM910",
        "SLF",
        "SLF0",
        "SLF00",
        "SLF001",
        "T",
        "T1",
        "T10",
        "T100",
        "T2",
        "T20",
        "T201",
        "T203",
        "TCH",
        "TCH0",
        "TCH00",
        "TCH001",
        "TCH002",
        "TCH003",
        "TCH004",
        "TCH005",
        "TD",
        "TD0",
        "TD00",
        "TD001",
        "TD002",
        "TD003",
        "TD004",
        "TD005",
        "TD006",
        "TD007",
        "TID",
        "TID2",
        "TID25",
        "TID251",
        "TID252",
        "TRY",
        "TRY0",
        "TRY00",
        "TRY002",
        "TRY003",
        "TRY004",
        "TRY2",
        "TRY20",
        "TRY200",
        "TRY201",
        "TRY3",
        "TRY30",
        "TRY300",
        "TRY301",
        "TRY302",
        "TRY4",
        "TRY40",
        "TRY400",
        "TRY401",
        "UP",
        "UP0",
        "UP00",
        "UP001",
        "UP003",
        "UP004",
        "UP005",
        "UP006",
        "UP007",
        "UP008",
        "UP009",
        "UP01",
        "UP010",
        "UP011",
        "UP012",
        "UP013",
        "UP014",
        "UP015",
        "UP017",
        "UP018",
        "UP019",
        "UP02",
        "UP020",
        "UP021",
        "UP022",
        "UP023",
        "UP024",
        "UP025",
        "UP026",
        "UP027",
        "UP028",
        "UP029",
        "UP03",
        "UP030",
        "UP031",
        "UP032",
        "UP033",
        "UP034",
        "UP035",
        "UP036",
        "UP037",
        "UP038",
        "W",
        "W1",
        "W19",
        "W191",
        "W2",
        "W29",
        "W291",
        "W292",
        "W293",
        "W5",
        "W50",
        "W505",
        "W6",
        "W60",
        "W605",
        "YTT",
        "YTT1",
        "YTT10",
        "YTT101",
        "YTT102",
        "YTT103",
        "YTT2",
        "YTT20",
        "YTT201",
        "YTT202",
        "YTT203",
        "YTT204",
        "YTT3",
        "YTT30",
        "YTT301",
        "YTT302",
        "YTT303"
      ]
    },
    "SerializationFormat": {
      "type": "string",
      "enum": [
        "text",
        "json",
        "junit",
        "grouped",
        "github",
        "gitlab",
        "pylint",
        "azure"
      ]
    },
    "Strictness": {
      "oneOf": [
        {
          "description": "Ban imports that extend into the parent module or beyond.",
          "type": "string",
          "enum": [
            "parents"
          ]
        },
        {
          "description": "Ban all relative imports.",
          "type": "string",
          "enum": [
            "all"
          ]
        }
      ]
    },
    "Version": {
      "type": "string"
    }
  }
}