[MASTER]

max-line-length=80
disable=all
output-format=colorized
score=no
reports=no
enable=
    assert-on-tuple,
    bad-indentation,
    bad-option-value,
    bad-reversed-sequence,
    bad-super-call,
    consider-merging-isinstance,
    continue-in-finally,
    cyclic-import,
    dangerous-default-value,
    duplicate-argument-name,
    empty-docstring,
    expression-not-assigned,
    function-redefined,
    import-self,
    invalid-name,
    relative-import,
    inconsistent-mro,
    init-is-generator,
    line-too-long,
    lost-exception,
    missing-docstring,
    missing-kwoa,
    mixed-indentation,
    mixed-line-endings,
    multiple-imports,
    no-else-return,
    not-callable,
    no-value-for-parameter,
    nonexistent-operator,
    not-in-loop,
    pointless-statement,
    redefined-builtin,
    relative-import,
    return-arg-in-generator,
    return-in-init,
    return-outside-function,
    simplifiable-if-statement,
    syntax-error,
    too-many-function-args,
    trailing-whitespace,
    undefined-variable,
    unexpected-keyword-arg,
    unhashable-dict-key,
    unnecessary-pass,
    unreachable,
    unrecognized-inline-option,
    unused-import,
    unnecessary-semicolon,
    unused-variable,
    unused-wildcard-import,
    wildcard-import,
    wrong-import-order,
    wrong-import-position,
    wrong-spelling-in-comment,
    wrong-spelling-in-docstrin,
    wildcard-import,
    yield-outside-function,

# Ignore long lines containing urls or pylint directives.
ignore-long-lines=^(\s*(#\s*)?<?https?://\S+>?)$

# Include a hint for the correct naming format with invalid-name
include-naming-hint=yes

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

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

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

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

# 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,30}$

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

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

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

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

# Naming hint for class attribute names
class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,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_]{2,60}$

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