Settings#
Top-level#
allowed-confusables#
A list of allowed "confusable" Unicode characters to ignore when
enforcing RUF001, RUF002, and RUF003.
Default value: []
Type: list[str]
Example usage:
[tool.ruff]
# Allow minus-sign (U+2212), greek-small-letter-rho (U+03C1), and the asterisk-operator (U+2217),
# which could be confused for "-", "p", and "*", respectively.
allowed-confusables = ["−", "ρ", "∗"]
builtins#
A list of builtins to treat as defined references, in addition to the system builtins.
Default value: []
Type: list[str]
Example usage:
cache-dir#
A path to the cache directory.
By default, Ruff stores cache results in a .ruff_cache directory in
the current project root.
However, Ruff will also respect the RUFF_CACHE_DIR environment
variable, which takes precedence over that default.
This setting will override even the RUFF_CACHE_DIR environment
variable, if set.
Default value: .ruff_cache
Type: str
Example usage:
dummy-variable-rgx#
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_.
Default value: "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
Type: re.Pattern
Example usage:
exclude#
A list of file patterns to exclude from linting.
Exclusions are based on globs, and can be either:
- Single-path patterns, like
.mypy_cache(to exclude any directory named.mypy_cachein the tree),foo.py(to exclude any file namedfoo.py), orfoo_*.py(to exclude any file matchingfoo_*.py). - Relative patterns, like
directory/foo.py(to exclude that specific file) ordirectory/*.py(to exclude any Python files indirectory). Note that these paths are relative to the project root (e.g., the directory containing yourpyproject.toml).
For more information on the glob syntax, refer to the globset documentation.
Note that you'll typically want to use
extend-exclude to modify the excluded paths.
Default value: [".bzr", ".direnv", ".eggs", ".git", ".git-rewrite", ".hg", ".mypy_cache", ".nox", ".pants.d", ".pytype", ".ruff_cache", ".svn", ".tox", ".venv", "__pypackages__", "_build", "buck-out", "build", "dist", "node_modules", "venv"]
Type: list[str]
Example usage:
extend#
A path to a local pyproject.toml file to merge into this
configuration. User home directory and environment variables will be
expanded.
To 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.
Default value: None
Type: str
Example usage:
[tool.ruff]
# Extend the `pyproject.toml` file in the parent directory.
extend = "../pyproject.toml"
# But use a different line length.
line-length = 100
extend-exclude#
A list of file patterns to omit from linting, in addition to those
specified by exclude.
Exclusions are based on globs, and can be either:
- Single-path patterns, like
.mypy_cache(to exclude any directory named.mypy_cachein the tree),foo.py(to exclude any file namedfoo.py), orfoo_*.py(to exclude any file matchingfoo_*.py). - Relative patterns, like
directory/foo.py(to exclude that specific file) ordirectory/*.py(to exclude any Python files indirectory). Note that these paths are relative to the project root (e.g., the directory containing yourpyproject.toml).
For more information on the glob syntax, refer to the globset documentation.
Default value: []
Type: list[str]
Example usage:
[tool.ruff]
# In addition to the standard set of exclusions, omit all tests, plus a specific file.
extend-exclude = ["tests", "src/bad.py"]
extend-fixable#
A list of rule codes or prefixes to consider autofixable, in addition to those
specified by fixable.
Default value: []
Type: list[RuleSelector]
Example usage:
[tool.ruff]
# Enable autofix for flake8-bugbear (`B`), on top of any rules specified by `fixable`.
extend-fixable = ["B"]
extend-ignore#
A list of rule codes or prefixes to ignore, in addition to those
specified by ignore.
This option has been deprecated in favor of ignore
since its usage is now interchangeable with ignore.
Default value: []
Type: list[RuleSelector]
Example usage:
extend-include#
A list of file patterns to include when linting, in addition to those
specified by include.
Inclusion are based on globs, and should be single-path patterns, like
*.pyw, to include any file with the .pyw extension.
For more information on the glob syntax, refer to the globset documentation.
Default value: []
Type: list[str]
Example usage:
[tool.ruff]
# In addition to the standard set of inclusions, include `.pyw` files.
extend-include = ["*.pyw"]
extend-per-file-ignores#
A list of mappings from file pattern to rule codes or prefixes to
exclude, in addition to any rules excluded by per-file-ignores.
Default value: {}
Type: dict[str, list[RuleSelector]]
Example usage:
[tool.ruff]
# Also ignore `E401` in all `__init__.py` files.
[tool.ruff.extend-per-file-ignores]
"__init__.py" = ["E402"]
extend-select#
A list of rule codes or prefixes to enable, in addition to those
specified by select.
Default value: []
Type: list[RuleSelector]
Example usage:
[tool.ruff]
# On top of the default `select` (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
extend-select = ["B", "Q"]
external#
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.
Default value: []
Type: list[str]
Example usage:
[tool.ruff]
# Avoiding flagging (and removing) `V101` from any `# noqa`
# directives, despite Ruff's lack of support for `vulture`.
external = ["V101"]
fix#
Enable autofix behavior by-default when running ruff (overridden
by the --fix and --no-fix command-line flags).
Default value: false
Type: bool
Example usage:
fix-only#
Like fix, but disables reporting on leftover violation. Implies fix.
Default value: false
Type: bool
Example usage:
fixable#
A list of rule codes or prefixes to consider autofixable. By default, all rules are considered autofixable.
Default value: ["A", "ANN", "ARG", "B", "BLE", "C", "COM", "D", "DTZ", "E", "EM", "ERA", "EXE", "F", "FBT", "G", "I", "ICN", "INP", "ISC", "N", "PD", "PGH", "PIE", "PL", "PT", "PTH", "Q", "RET", "RUF", "S", "SIM", "T", "TCH", "TID", "TRY", "UP", "W", "YTT"]
Type: list[RuleSelector]
Example usage:
force-exclude#
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.
This is useful for pre-commit, which explicitly passes all
changed files to the ruff-pre-commit
plugin, regardless of whether they're marked as excluded by Ruff's own
settings.
Default value: false
Type: bool
Example usage:
format#
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).
Default value: "text"
Type: "text" | "json" | "junit" | "github" | "gitlab" | "pylint" | "azure"
Example usage:
ignore#
A list of rule codes or prefixes to ignore. Prefixes can specify exact
rules (like F841), entire categories (like F), or anything in
between.
When breaking ties between enabled and disabled rules (via select and
ignore, respectively), more specific prefixes override less
specific prefixes.
Default value: []
Type: list[RuleSelector]
Example usage:
ignore-init-module-imports#
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).
Default value: false
Type: bool
Example usage:
include#
A list of file patterns to include when linting.
Inclusion are based on globs, and should be single-path patterns, like
*.pyw, to include any file with the .pyw extension.
For more information on the glob syntax, refer to the globset documentation.
Default value: ["*.py", "*.pyi"]
Type: list[str]
Example usage:
line-length#
The line length to use when enforcing long-lines violations (like
E501).
Default value: 88
Type: int
Example usage:
namespace-packages#
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.
Default value: []
Type: list[str]
Example usage:
per-file-ignores#
A list of mappings from file pattern to rule codes or prefixes to exclude, when considering any matching files.
Default value: {}
Type: dict[str, list[RuleSelector]]
Example usage:
[tool.ruff]
# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
[tool.ruff.per-file-ignores]
"__init__.py" = ["E402"]
"path/to/file.py" = ["E402"]
required-version#
Require a specific version of Ruff to be running (useful for unifying
results across many environments, e.g., with a pyproject.toml
file).
Default value: None
Type: str
Example usage:
respect-gitignore#
Whether to automatically exclude files that are ignored by .ignore,
.gitignore, .git/info/exclude, and global gitignore files.
Enabled by default.
Default value: true
Type: bool
Example usage:
select#
A list of rule codes or prefixes to enable. Prefixes can specify exact
rules (like F841), entire categories (like F), or anything in
between.
When breaking ties between enabled and disabled rules (via select and
ignore, respectively), more specific prefixes override less
specific prefixes.
Default value: ["E", "F"]
Type: list[RuleSelector]
Example usage:
[tool.ruff]
# On top of the defaults (`E`, `F`), enable flake8-bugbear (`B`) and flake8-quotes (`Q`).
select = ["E", "F", "B", "Q"]
show-fixes#
Whether to show an enumeration of all autofixed lint violations
(overridden by the --show-fixes command-line flag).
Default value: false
Type: bool
Example usage:
show-source#
Whether to show source code snippets when reporting lint violations
(overridden by the --show-source command-line flag).
Default value: false
Type: bool
Example usage:
src#
The source code paths to consider, e.g., when resolving first- vs. third-party imports.
As an example: given a Python package structure like:
The 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.
This 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.
Default value: ["."]
Type: list[str]
Example usage:
tab-size#
The tabulation size to calculate line length.
Default value: 4
Type: int
Example usage:
target-version#
The Python version to target, e.g., when considering automatic code upgrades, like rewriting type annotations.
If 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.
Default value: "py310"
Type: "py37" | "py38" | "py39" | "py310" | "py311"
Example usage:
task-tags#
A list of task tags to recognize (e.g., "TODO", "FIXME", "XXX").
Comments 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.
Default value: ["TODO", "FIXME", "XXX"]
Type: list[str]
Example usage:
typing-modules#
A list of modules whose imports should be treated equivalently to
members of the typing module.
This 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.
Default value: []
Type: list[str]
Example usage:
unfixable#
A list of rule codes or prefixes to consider non-autofix-able.
Default value: []
Type: list[RuleSelector]
Example usage:
flake8-annotations#
allow-star-arg-any#
Whether to suppress ANN401 for dynamically typed *args and
**kwargs arguments.
Default value: false
Type: bool
Example usage:
ignore-fully-untyped#
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.
Default value: false
Type: bool
Example usage:
mypy-init-return#
Whether to allow the omission of a return type hint for __init__ if at
least one argument is annotated.
Default value: false
Type: bool
Example usage:
suppress-dummy-args#
Whether to suppress ANN000-level violations for arguments matching the
"dummy" variable regex (like _).
Default value: false
Type: bool
Example usage:
suppress-none-returning#
Whether to suppress ANN200-level violations for functions that meet
either of the following criteria:
- Contain no
returnstatement. - Explicit
returnstatement(s) all returnNone(explicitly or implicitly).
Default value: false
Type: bool
Example usage:
flake8-bandit#
check-typed-exception#
Whether to disallow try-except-pass (S110) for specific
exception types. By default, try-except-pass is only
disallowed for Exception and BaseException.
Default value: false
Type: bool
Example usage:
hardcoded-tmp-directory#
A list of directories to consider temporary.
Default value: ["/tmp", "/var/tmp", "/dev/shm"]
Type: list[str]
Example usage:
hardcoded-tmp-directory-extend#
A list of directories to consider temporary, in addition to those
specified by hardcoded-tmp-directory.
Default value: []
Type: list[str]
Example usage:
flake8-bugbear#
extend-immutable-calls#
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).
Default value: []
Type: list[str]
Example usage:
[tool.ruff.flake8-bugbear]
# Allow default arguments like, e.g., `data: List[str] = fastapi.Query(None)`.
extend-immutable-calls = ["fastapi.Depends", "fastapi.Query"]
flake8-builtins#
builtins-ignorelist#
Ignore list of builtins.
Default value: []
Type: list[str]
Example usage:
flake8-comprehensions#
allow-dict-calls-with-keyword-arguments#
Allow dict calls that make use of keyword arguments (e.g., dict(a=1, b=2)).
Default value: false
Type: bool
Example usage:
flake8-errmsg#
max-string-length#
Maximum string length for string literals in exception messages.
Default value: 0
Type: int
Example usage:
flake8-gettext#
extend-function-names#
Additional function names to consider as internationalization calls, in addition to those
included in function-names.
Default value: []
Type: list[str]
Example usage:
function-names#
The function names to consider as internationalization calls.
Default value: ["_", "gettext", "ngettext"]
Type: list[str]
Example usage:
flake8-implicit-str-concat#
allow-multiline#
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).
Note 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.
Default value: true
Type: bool
Example usage:
flake8-import-conventions#
aliases#
The conventional aliases for imports. These aliases can be extended by
the extend_aliases option.
Default value: {"altair": "alt", "matplotlib": "mpl", "matplotlib.pyplot": "plt", "numpy": "np", "pandas": "pd", "seaborn": "sns", "tensorflow": "tf", "holoviews": "hv", "panel": "pn", "plotly.express": "px", "polars": "pl", "pyarrow": "pa"}
Type: dict[str, str]
Example usage:
[tool.ruff.flake8-import-conventions]
[tool.ruff.flake8-import-conventions.aliases]
# Declare the default aliases.
altair = "alt"
"matplotlib.pyplot" = "plt"
numpy = "np"
pandas = "pd"
seaborn = "sns"
scipy = "sp"
banned-aliases#
A mapping from module to its banned import aliases.
Default value: {}
Type: dict[str, list[str]]
Example usage:
[tool.ruff.flake8-import-conventions]
[tool.ruff.flake8-import-conventions.banned-aliases]
# Declare the banned aliases.
"tensorflow.keras.backend" = ["K"]
banned-from#
A list of modules that are allowed to be imported from
Default value: []
Type: list[str]
Example usage:
extend-aliases#
A mapping from module to conventional import alias. These aliases will
be added to the aliases mapping.
Default value: {}
Type: dict[str, str]
Example usage:
[tool.ruff.flake8-import-conventions]
[tool.ruff.flake8-import-conventions.extend-aliases]
# Declare a custom alias for the `matplotlib` module.
"dask.dataframe" = "dd"
flake8-pytest-style#
fixture-parentheses#
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.
Default value: true
Type: bool
Example usage:
mark-parentheses#
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.
Default value: true
Type: bool
Example usage:
parametrize-names-type#
Expected type for multiple argument names in @pytest.mark.parametrize.
The following values are supported:
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'], ...)
Default value: tuple
Type: "csv" | "tuple" | "list"
Example usage:
parametrize-values-row-type#
Expected type for each row of values in @pytest.mark.parametrize in
case of multiple parameters. The following values are supported:
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]])
Default value: tuple
Type: "tuple" | "list"
Example usage:
parametrize-values-type#
Expected type for the list of values rows in @pytest.mark.parametrize.
The following values are supported:
tuple— e.g.@pytest.mark.parametrize('name', (1, 2, 3))list(default) — e.g.@pytest.mark.parametrize('name', [1, 2, 3])
Default value: list
Type: "tuple" | "list"
Example usage:
raises-extend-require-match-for#
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.
Default value: []
Type: list[str]
Example usage:
raises-require-match-for#
List of exception names that require a match= parameter in a
pytest.raises() call.
Default value: ["BaseException", "Exception", "ValueError", "OSError", "IOError", "EnvironmentError", "socket.error"]
Type: list[str]
Example usage:
flake8-quotes#
avoid-escape#
Whether to avoid using single quotes if a string contains single quotes, or vice-versa with double quotes, as per PEP 8. This minimizes the need to escape quotation marks within strings.
Default value: true
Type: bool
Example usage:
docstring-quotes#
Quote style to prefer for docstrings (either "single" or "double").
Default value: "double"
Type: "single" | "double"
Example usage:
inline-quotes#
Quote style to prefer for inline strings (either "single" or "double").
Default value: "double"
Type: "single" | "double"
Example usage:
multiline-quotes#
Quote style to prefer for multiline strings (either "single" or "double").
Default value: "double"
Type: "single" | "double"
Example usage:
flake8-self#
ignore-names#
A list of names to ignore when considering flake8-self violations.
Default value: ["_make", "_asdict", "_replace", "_fields", "_field_defaults"]
Type: list[str]
Example usage:
flake8-tidy-imports#
ban-relative-imports#
Whether to ban all relative imports ("all"), or only those imports
that extend into the parent module or beyond ("parents").
Default value: "parents"
Type: "parents" | "all"
Example usage:
banned-api#
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.
Default value: {}
Type: dict[str, { "msg": str }]
Example usage:
[tool.ruff.flake8-tidy-imports]
[tool.ruff.flake8-tidy-imports.banned-api]
"cgi".msg = "The cgi module is deprecated, see https://peps.python.org/pep-0594/#cgi."
"typing.TypedDict".msg = "Use typing_extensions.TypedDict instead."
flake8-type-checking#
exempt-modules#
Exempt certain modules from needing to be moved into type-checking blocks.
Default value: ["typing"]
Type: list[str]
Example usage:
runtime-evaluated-base-classes#
Exempt classes that list any of the enumerated classes as a base class from needing to be moved into type-checking blocks.
Default value: []
Type: list[str]
Example usage:
runtime-evaluated-decorators#
Exempt classes decorated with any of the enumerated decorators from needing to be moved into type-checking blocks.
Default value: []
Type: list[str]
Example usage:
strict#
Enforce TC001, TC002, and TC003 rules even when valid runtime imports are present for the same module. See flake8-type-checking's strict option.
Default value: false
Type: bool
Example usage:
flake8-unused-arguments#
ignore-variadic-names#
Whether to allow unused variadic arguments, like *args and **kwargs.
Default value: false
Type: bool
Example usage:
isort#
classes#
An override list of tokens to always recognize as a Class for
order-by-type regardless of casing.
Default value: []
Type: list[str]
Example usage:
combine-as-imports#
Combines as imports on the same line. See isort's combine-as-imports
option.
Default value: false
Type: bool
Example usage:
constants#
An override list of tokens to always recognize as a CONSTANT
for order-by-type regardless of casing.
Default value: []
Type: list[str]
Example usage:
extra-standard-library#
A list of modules to consider standard-library, in addition to those known to Ruff in advance.
Default value: []
Type: list[str]
Example usage:
force-single-line#
Forces all from imports to appear on their own line.
Default value: false
Type: bool
Example usage:
force-sort-within-sections#
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.
Default value: false
Type: bool
Example usage:
force-to-top#
Force specific imports to the top of their appropriate section.
Default value: []
Type: list[str]
Example usage:
force-wrap-aliases#
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:
Note 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.
Default value: false
Type: bool
Example usage:
forced-separate#
A list of modules to separate into auxiliary block(s) of imports, in the order specified.
Default value: []
Type: list[str]
Example usage:
known-first-party#
A list of modules to consider first-party, regardless of whether they can be identified as such via introspection of the local filesystem.
Default value: []
Type: list[str]
Example usage:
known-local-folder#
A list of modules to consider being a local folder.
Generally, this is reserved for relative imports (from . import module).
Default value: []
Type: list[str]
Example usage:
known-third-party#
A list of modules to consider third-party, regardless of whether they can be identified as such via introspection of the local filesystem.
Default value: []
Type: list[str]
Example usage:
lines-after-imports#
The number of blank lines to place after imports.
Use -1 for automatic determination.
Default value: -1
Type: int
Example usage:
lines-between-types#
The number of lines to place between "direct" and import from imports.
Default value: 0
Type: int
Example usage:
no-lines-before#
A list of sections that should not be delineated from the previous section via empty lines.
Default value: []
Type: list["future" | "standard-library" | "third-party" | "first-party" | "local-folder" | str]
Example usage:
order-by-type#
Order imports by type, which is determined by case, in addition to alphabetically.
Default value: true
Type: bool
Example usage:
relative-imports-order#
Whether to place "closer" imports (fewer . characters, most local)
before "further" imports (more . characters, least local), or vice
versa.
The 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.
Default value: furthest-to-closest
Type: "furthest-to-closest" | "closest-to-furthest"
Example usage:
required-imports#
Add the specified import line to all files.
Default value: []
Type: list[str]
Example usage:
section-order#
Override in which order the sections should be output. Can be used to move custom sections.
Default value: ["future", "standard-library", "third-party", "first-party", "local-folder"]
Type: list["future" | "standard-library" | "third-party" | "first-party" | "local-folder" | str]
Example usage:
[tool.ruff.isort]
section-order = ["future", "standard-library", "first-party", "local-folder", "third-party"]
sections#
A list of mappings from section names to modules.
By default custom sections are output last, but this can be overridden with section-order.
Default value: {}
Type: dict[str, list[str]]
Example usage:
[tool.ruff.isort]
# Group all Django imports into a separate section.
[tool.ruff.isort.sections]
"django" = ["django"]
single-line-exclusions#
One or more modules to exclude from the single line rule.
Default value: []
Type: list[str]
Example usage:
split-on-trailing-comma#
If a comma is placed after the last member in a multi-line import, then the imports will never be folded into one line.
See isort's split-on-trailing-comma option.
Default value: true
Type: bool
Example usage:
variables#
An override list of tokens to always recognize as a var
for order-by-type regardless of casing.
Default value: []
Type: list[str]
Example usage:
mccabe#
max-complexity#
The maximum McCabe complexity to allow before triggering C901 errors.
Default value: 10
Type: int
Example usage:
[tool.ruff.mccabe]
# Flag errors (`C901`) whenever the complexity level exceeds 5.
max-complexity = 5
pep8-naming#
classmethod-decorators#
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).
For example, Ruff will expect that any method decorated by a decorator
in this list takes a cls argument as its first argument.
Default value: []
Type: list[str]
Example usage:
[tool.ruff.pep8-naming]
# Allow Pydantic's `@validator` decorator to trigger class method treatment.
classmethod-decorators = ["pydantic.validator"]
ignore-names#
A list of names to ignore when considering pep8-naming violations.
Default value: ["setUp", "tearDown", "setUpClass", "tearDownClass", "setUpModule", "tearDownModule", "asyncSetUp", "asyncTearDown", "setUpTestData", "failureException", "longMessage", "maxDiff"]
Type: list[str]
Example usage:
staticmethod-decorators#
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).
For example, Ruff will expect that any method decorated by a decorator
in this list has no self or cls argument.
Default value: []
Type: list[str]
Example usage:
[tool.ruff.pep8-naming]
# Allow a shorthand alias, `@stcmthd`, to trigger static method treatment.
staticmethod-decorators = ["stcmthd"]
pycodestyle#
ignore-overlong-task-comments#
Whether line-length violations (E501) should be triggered for
comments starting with task-tags (by default: ["TODO", "FIXME",
and "XXX"]).
Default value: false
Type: bool
Example usage:
max-doc-length#
The maximum line length to allow for line-length violations within
documentation (W505), including standalone comments.
Default value: None
Type: int
Example usage:
pydocstyle#
convention#
Whether to use Google-style or NumPy-style conventions or the PEP257 defaults when analyzing docstring sections.
Default value: None
Type: "google" | "numpy" | "pep257"
Example usage:
ignore-decorators#
Ignore docstrings for functions or methods decorated with the specified fully-qualified decorators.
Default value: []
Type: list[str]
Example usage:
property-decorators#
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).
For example, Ruff will expect that any method decorated by a decorator in this list can use a non-imperative summary line.
Default value: []
Type: list[str]
Example usage:
pylint#
allow-magic-value-types#
Constant types to ignore when used as "magic values" (see: PLR2004).
Default value: ["str", "bytes"]
Type: list["str" | "bytes" | "complex" | "float" | "int" | "tuple"]
Example usage:
max-args#
Maximum number of arguments allowed for a function or method definition
(see: PLR0913).
Default value: 5
Type: int
Example usage:
max-branches#
Maximum number of branches allowed for a function or method body (see:
PLR0912).
Default value: 12
Type: int
Example usage:
max-returns#
Maximum number of return statements allowed for a function or method
body (see PLR0911)
Default value: 6
Type: int
Example usage:
max-statements#
Maximum number of statements allowed for a function or method body (see:
PLR0915).
Default value: 50
Type: int
Example usage: