setup.cfg

[flake8]
max-line-length = 88
extend-ignore = E203
ignore = F401, F402, F403, F404, F405, F406, F407,  # imports already checked by pylint
  W503  # line break before binary operator for black compatibility

[pylint.MESSAGES CONTROL]

disable=
    fixme,
    missing-docstring,
    line-too-long,
    too-many-lines,
    wrong-spelling-in-comment,
    wrong-spelling-in-docstring,
    invalid-characters-in-docstring,
    len-as-condition,
    import-error,
    attribute-defined-outside-init,
    duplicate-code,
    protected-access,
    too-few-public-methods,
    too-many-ancestors,
    too-many-instance-attributes,
    too-many-public-methods,
    too-many-return-statements,
    too-many-branches,
    too-many-arguments,
    too-many-locals,
    too-many-statements,
    too-many-boolean-expressions,
    too-many-nested-blocks,
    consider-using-join,
    consider-using-in,
    consider-using-get,
    chained-comparison,
    simplifiable-if-expression,
    no-init,
    logging-not-lazy,
    logging-format-interpolation,
    logging-fstring-interpolation,
    deprecated-method,
    reload-builtin,
    oct-method,
    hex-method,
    nonzero-method,
    cmp-method,
    input-builtin,
    round-builtin,
    intern-builtin,
    unichr-builtin,
    map-builtin-not-iterating,
    zip-builtin-not-iterating,
    range-builtin-not-iterating,
    filter-builtin-not-iterating,
    deprecated-string-function,
    deprecated-str-translate-call,
    deprecated-itertools-function,
    deprecated-types-field,
    next-method-defined,
    dict-items-not-iterating,
    dict-keys-not-iterating,
    dict-values-not-iterating,
    bad-whitespace,
    bad-continuation,
    unnecessary-comprehension,
    duplicate-string-formatting-argument,
    unnecessary-pass,
    unnecessary-lambda,
    relative-beyond-top-level,
    # handled by black
    format

max-line-length = 88

# Regular expression matching correct function names
function-rgx=[a-z_][a-z0-9_]{1,}$

# Naming hint for function names
function-name-hint=[a-z_][a-z0-9_]{1,}$

# Regular expression matching correct variable names
variable-rgx=[a-z_][a-z0-9_]{0,}$

# Naming hint for variable names
variable-name-hint=[a-z_][a-z0-9_]{0,}$

# Regular expression matching correct constant names
const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$

# Naming hint for constant names
const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$

# Regular expression matching correct attribute names
attr-rgx=[a-z_][a-z0-9_]{0,}$

# Naming hint for attribute names
attr-name-hint=[a-z_][a-z0-9_]{0,}$

# Regular expression matching correct argument names
argument-rgx=[a-z_][a-z0-9_]{0,}$

# Naming hint for argument names
argument-name-hint=[a-z_][a-z0-9_]{0,}$

# Regular expression matching correct class attribute names
class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{1,30}|(__.*__))$

# Naming hint for class attribute names
class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{1,30}|(__.*__))$

# Regular expression matching correct inline iteration names
inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$

# Naming hint for inline iteration names
inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$

# Regular expression matching correct class names
class-rgx=[A-Z_][a-zA-Z0-9]+$

# Naming hint for class names
class-name-hint=[A-Z_][a-zA-Z0-9]+$

# Regular expression matching correct module names
module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

# Naming hint for module names
module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

# Regular expression matching correct method names
method-rgx=[a-z_][a-z0-9_]{1,}$

# Naming hint for method names
method-name-hint=[a-z_][a-z0-9_]{1,}$

init-import=no