.pylintrc

[MASTER]

# Use multiple processes to speed up Pylint.
jobs=2


[MESSAGES CONTROL]

disable=
        duplicate-code,
        old-octal-literal,
        oct-method,
        unpacking-in-except,
        parameter-unpacking,
        backtick,
        old-raise-syntax,
        old-ne-operator,
        long-suffix,
        dict-view-method,
        dict-iter-method,
        metaclass-assignment,
        next-method-called,
        raising-string,
        indexing-exception,
        raw_input-builtin,
        long-builtin,
        file-builtin,
        execfile-builtin,
        coerce-builtin,
        cmp-builtin,
        buffer-builtin,
        basestring-builtin,
        apply-builtin,
        filter-builtin-not-iterating,
        using-cmp-argument,
        useless-suppression,
        range-builtin-not-iterating,
        suppressed-message,
        missing-docstring,
        no-absolute-import,
        old-division,
        cmp-method,
        reload-builtin,
        zip-builtin-not-iterating,
        intern-builtin,
        unichr-builtin,
        reduce-builtin,
        standarderror-builtin,
        unicode-builtin,
        xrange-builtin,
        coerce-method,
        delslice-method,
        getslice-method,
        setslice-method,
        input-builtin,
        round-builtin,
        hex-method,
        nonzero-method,
        map-builtin-not-iterating,
        relative-import,
        invalid-name,
        bad-continuation,
        no-member,
        locally-disabled,
        fixme,
        import-error,
        too-many-locals,
        no-name-in-module,
        too-many-instance-attributes,
        no-self-use,
        logging-fstring-interpolation


[BASIC]

# Usable variable names, which should always be accepted, are separated by a comma
good-names=i,j,k,ex,Run,_

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

# Regular expression that matches the correct function names
function-rgx=[a-z_][a-z0-9_]{2,30}$

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

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

# Naming hint for variable names
variable-name-hint=[a-z_][a-z0-9_]{2,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_]{2,30}$

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

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

# Naming hint for argument names
argument-name-hint=[a-z_][a-z0-9_]{2,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,30}$

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


[ELIF]

# Maximum number of nested blocks for the function / method body
max-nested-blocks=10


[FORMAT]

# Maximum number of characters on a single line.
max-line-length=120

# List of optional constructs for which whitespace checking is disabled. `dict-
# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
# `trailing-comma` allows a space between comma and closing bracket: (a, ).
# `empty-line` allows space-only lines.
no-space-check=trailing-comma,dict-separator

# Maximum number of lines in a module
max-module-lines=1000


[MISCELLANEOUS]

# List of note tags to take in consideration, separated by a comma.
notes=FIXME,XXX,TODO


[VARIABLES]

# Tells whether we should check for unused import in __init__ files.
init-import=no

# A regular expression matching the name of dummy variables (i.e. expectedly
# not used).
dummy-variables-rgx=(_+[a-zA-Z0-9]*?$)|dummy


[LOGGING]

# Logging modules to check that the string format arguments are in logging
# function parameter format
logging-modules=logging


[SIMILARITIES]

# Minimum line number of the similarity.
min-similarity-lines=4

# Ignore comments when computing similarities.
ignore-comments=no

# Ignore docstrings when computing similarities.
ignore-docstrings=yes

# Ignore imports when computing similarities.
ignore-imports=yes


[IMPORTS]

# Deprecated modules, which should not be used, are separated by a comma
deprecated-modules=regsub,TERMIOS,Bastion,rexec



[DESIGN]

# Maximum number of arguments for the function / method
max-args=15

# Maximum number of locals for the function / method body
max-locals=15

# Maximum number of return / yield for the function / method body
max-returns=6

# Maximum number of branches for the function / method body
max-branches=10

# Maximum number of statements in the function / method body
max-statements=30

# Maximum number of parents for the class (see R0901).
max-parents=7

# Maximum number of attributes for the class (see R0902).
max-attributes=7

# Minimum number of public methods for the class (see R0903).
min-public-methods=0

# Maximum number of public methods for the class (see R0904).
max-public-methods=20

# Maximum number of boolean expressions in the if statement
max-bool-expr=5


[CLASSES]

# List of method names used to declare (i.e. assign) instance attributes.
defining-attr-methods=__init__,__new__,setUp

# List of valid names for the first argument in a class method.
valid-classmethod-first-arg=cls

# List of valid names for the first argument in a metaclass class method.
valid-metaclass-classmethod-first-arg=mcs

# List of member names, which should be excluded from the protected access
# warning.
exclude-protected=_asdict,_fields,_replace,_source,_make


[EXCEPTIONS]

# Exceptions that will emit a warning when being caught. Defaults to
# "Exception"
overgeneral-exceptions=Exception