.pylintrc

# Based on Apache 2.0 licensed code from https://github.com/ClusterHQ/flocker

[MASTER]

# Add files or directories to the blacklist. They should be base names, not paths.

# Pickle collected data for later comparisons.
persistent=no

# List of plugins (as comma separated values of python modules names) to load, usually to register additional checkers.
load-plugins=

# Use multiple processes to speed up Pylint.
# DO NOT CHANGE THIS VALUES >1 HIDE RESULTS!!!!!
jobs=1

# Allow loading of arbitrary C extensions. Extensions are imported into the active Python interpreter and may run
# arbitrary code.
unsafe-load-any-extension=no

# A comma-separated list of package or module names from where C extensions may be loaded. Extensions are loading into
# the active Python interpreter and may run arbitrary code
extension-pkg-whitelist=

# Allow optimization of some AST trees. This will activate a peephole AST optimizer, which will apply various small
# optimizations. For instance, it can be used to obtain the result of joining multiple strings with the addition
# operator. Joining a lot of strings can lead to a maximum recursion error in Pylint and this flag can prevent that. It
# has one side effect, the resulting AST will be different than the one from reality.
optimize-ast=no


[MESSAGES CONTROL]

# Only show warnings with the listed confidence levels. Leave empty to show all. Valid levels: HIGH, INFERENCE,
# INFERENCE_FAILURE, UNDEFINED
confidence=

# Enable the message, report, category or checker with the given id(s). You can either give multiple identifier
# separated by comma (,) or put this option multiple time. See also the "--disable" option for examples.
disable=all

enable=abstract-class-instantiated,
      abstract-method,
      access-member-before-definition,
      anomalous-backslash-in-string,
      anomalous-unicode-escape-in-string,
      #arguments-differ,
      arguments-out-of-order,
      assert-on-tuple,
      assign-to-new-keyword,
      assigning-non-slot,
      assignment-from-no-return,
      assignment-from-none,
      astroid-error,
      attribute-defined-outside-init,
      backtick,
      bad-classmethod-argument,
      bad-except-order,
      bad-exception-context,
      bad-format-character,
      bad-format-string,
      bad-format-string-key,
      bad-indentation,
      bad-inline-option,
      bad-mcs-classmethod-argument,
      bad-mcs-method-argument,
      bad-open-mode,
      bad-option-value,
      bad-python3-import,
      bad-reversed-sequence,
      bad-staticmethod-argument,
      bad-str-strip-call,
      bad-string-format-type,
      bad-super-call,
      bad-thread-instantiation,
      bad-whitespace,
      bare-except,
      binary-op-exception,
      blacklisted-name,
      boolean-datetime,
      broad-except,
      c-extension-no-member,
      catching-non-exception,
      cell-var-from-loop,
      chained-comparison,
      class-variable-slots-conflict,
      cmp-method,
      coerce-method,
      comparison-with-callable,
      comparison-with-itself,
      comprehension-escape,
      confusing-with-statement,
      consider-iterating-dictionary,
      consider-merging-isinstance,
      consider-swap-variables,
      consider-using-dict-comprehension,
      consider-using-enumerate,
      consider-using-get,
      consider-using-in,
      consider-using-join,
      consider-using-set-comprehension,
      consider-using-sys-exit,
      consider-using-ternary,
      continue-in-finally,
      cyclic-import,
      dangerous-default-value,
      delslice-method,
      deprecated-itertools-function,
      deprecated-method,
      deprecated-module,
      deprecated-operator-function,
      deprecated-pragma,
      deprecated-str-translate-call,
      deprecated-string-function,
      deprecated-sys-function,
      deprecated-types-field,
      deprecated-urllib-function,
      dict-items-not-iterating,
      dict-iter-method,
      dict-iter-missing-items,
      dict-keys-not-iterating,
      dict-values-not-iterating,
      dict-view-method,
      div-method,
      duplicate-argument-name,
      duplicate-bases,
      duplicate-except,
      duplicate-key,
      duplicate-string-formatting-argument,
      empty-docstring,
      eq-without-hash,
      eval-used,
      exception-escape,
      exception-message-attribute,
      exec-used,
      expression-not-assigned,
      fatal,
      file-ignored,
      filter-builtin-not-iterating,
      fixme,
      format-combined-specification,
      format-needs-mapping,
      function-redefined,
      getslice-method,
      global-at-module-level,
      global-statement,
      global-variable-not-assigned,
      global-variable-undefined,
      hex-method,
      idiv-method,
      implicit-str-concat-in-sequence,
      import-error,
      import-outside-toplevel,
      import-self,
      import-star-module-level,
      inconsistent-mro,
      indexing-exception,
      inherit-non-class,
      init-is-generator,
      invalid-all-object,
      invalid-characters-in-docstring,
      invalid-envvar-default,
      invalid-envvar-value,
      invalid-format-index,
      invalid-length-returned,
      invalid-metaclass,
      invalid-name,
      invalid-overridden-method,
      invalid-sequence-index,
      invalid-slice-index,
      invalid-slots,
      invalid-slots-object,
      invalid-star-assignment-target,
      invalid-str-codec,
      invalid-unary-operand-type,
      keyword-arg-before-vararg,
      len-as-condition,
      line-too-long,
      literal-comparison,
      logging-format-interpolation,
      logging-format-truncated,
      logging-not-lazy,
      logging-too-few-args,
      logging-too-many-args,
      logging-unsupported-format,
      long-suffix,
      lost-exception,
      map-builtin-not-iterating,
      metaclass-assignment,
      method-check-failed,
      method-hidden,
      misplaced-bare-raise,
      misplaced-comparison-constant,
      misplaced-format-function,
      misplaced-future,
      #missing-docstring,
      missing-final-newline,
      missing-format-argument-key,
      missing-format-attribute,
      missing-format-string-key,
      missing-kwoa,
      missing-parentheses-for-call-in-test,
      mixed-format-string,
      mixed-indentation,
      mixed-line-endings,
      multiple-imports,
      multiple-statements,
      next-method-called,
      next-method-defined,
      no-classmethod-decorator,
      no-else-break,
      no-else-continue,
      no-else-raise,
      no-else-return,
      no-init,
      no-member,
      no-method-argument,
      no-name-in-module,
      no-self-argument,
      no-self-use,
      no-staticmethod-decorator,
      no-value-for-parameter,
      non-ascii-bytes-literal,
      non-iterator-returned,
      non-parent-init-called,
      nonexistent-operator,
      nonlocal-and-global,
      nonlocal-without-binding,
      nonzero-method,
      not-a-mapping,
      not-an-iterable,
      not-async-context-manager,
      not-callable,
      not-context-manager,
      not-in-loop,
      notimplemented-raised,
      oct-method,
      old-ne-operator,
      old-octal-literal,
      old-raise-syntax,
      parameter-unpacking,
      parse-error,
      pointless-statement,
      pointless-string-statement,
      possibly-unused-variable,
      preferred-module,
      print-statement,
      property-with-parameters,
      protected-access,
      raising-bad-type,
      raising-format-tuple,
      raising-non-exception,
      raising-string,
      range-builtin-not-iterating,
      raw-checker-failed,
      rdiv-method,
      redeclared-assigned-name,
      redefine-in-handler,
      redefined-argument-from-local,
      redefined-builtin,
      redefined-outer-name,
      redundant-keyword-arg,
      redundant-unittest-assert,
      reimported,
      relative-beyond-top-level,
      repeated-keyword,
      return-arg-in-generator,
      return-in-init,
      return-outside-function,
      self-assigning-variable,
      self-cls-assignment,
      setslice-method,
      shallow-copy-environ,
      signature-differs,
      simplifiable-if-expression,
      simplifiable-if-statement,
      simplify-boolean-expression,
      single-string-used-for-slots,
      singleton-comparison,
      star-needs-assignment-target,
      stop-iteration-return,
      subprocess-popen-preexec-fn,
      subprocess-run-check,
      super-init-not-called,
      syntax-error,
      sys-max-int,
      too-few-format-args,
      too-many-arguments,
      too-many-boolean-expressions,
      too-many-branches,
      too-many-format-args,
      too-many-function-args,
      too-many-instance-attributes,
      too-many-lines,
      too-many-locals,
      too-many-nested-blocks,
      too-many-public-methods,
      too-many-star-expressions,
      too-many-statements,
      trailing-comma-tuple,
      trailing-newlines,
      trailing-whitespace,
      truncated-format-string,
      try-except-raise,
      unbalanced-tuple-unpacking,
      undefined-all-variable,
      undefined-loop-variable,
      undefined-variable,
      unexpected-keyword-arg,
      unexpected-line-ending-format,
      unexpected-special-method-signature,
      ungrouped-imports,
      unhashable-dict-key,
      unidiomatic-typecheck,
      unnecessary-comprehension,
      unnecessary-lambda,
      unnecessary-pass,
      unnecessary-semicolon,
      unneeded-not,
      unpacking-in-except,
      unpacking-non-sequence,
      unreachable,
      unrecognized-inline-option,
      unsubscriptable-object,
      unsupported-assignment-operation,
      unsupported-binary-operation,
      unsupported-delete-operation,
      unsupported-membership-test,
      unused-argument,
      unused-format-string-argument,
      unused-format-string-key,
      unused-import,
      unused-variable,
      unused-wildcard-import,
      use-symbolic-message-instead,
      used-before-assignment,
      used-prior-global-declaration,
      useless-else-on-loop,
      useless-import-alias,
      useless-object-inheritance,
      useless-return,
      useless-super-delegation,
      using-cmp-argument,
      using-constant-test,
      wildcard-import,
      wrong-exception-operation,
      wrong-import-order,
      wrong-import-position,
      wrong-spelling-in-comment,
      wrong-spelling-in-docstring,
      xreadlines-attribute,
      yield-inside-async-function,
      yield-outside-function




[REPORTS]

# Set the output format. Available formats are text, parseable, colorized, msvs (visual studio) and html.
# You can also give a reporter class, eg mypackage.mymodule.MyReporterClass.
output-format=parseable

# Put messages in a separate file for each module / package specified on the command line instead of printing them on
# stdout. Reports (if any) will be written in a file name "pylint_global.[txt|html]".
files-output=no

# Tells whether to display a full report or only the messages
reports=no

# Python expression which should return a note less than 10 (10 is the highest note). You have access to the variables
# errors warning, statement which respectively contain the number of errors / warnings messages and the total number of
# statements analyzed. This is used by the global evaluation report (RP0004).
evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)

# Template used to display messages. This is a python new-style format string used to format the message information.
# See doc for all details
#msg-template=


[LOGGING]

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


[FORMAT]

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

# Regexp for a line that is allowed to be longer than the limit.
#ignore-long-lines=^\s*(# )?<?https?://\S+>?$
ignore-long-lines=^\s*(# )?<?https?://\S+>?$|^\s*(\w*\s*=\s*)?(\"|\').*(\"|\'),?\s*$

# Allow the body of an if to be on the same line as the test if there is no else.
single-line-if-stmt=no

# 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=2000

# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1 tab).
indent-string='    '

# Number of spaces of indent required inside a hanging  or continued line.
indent-after-paren=4

# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
expected-line-ending-format=


[TYPECHECK]

# Tells whether missing members accessed in mixin class should be ignored. A mixin class is detected if its name ends
# with "mixin" (case insensitive).
ignore-mixin-members=yes

# List of module names for which member attributes should not be checked (useful for modules/projects where namespaces
# are manipulated during runtime and thus existing member attributes cannot be deduced by static analysis. It supports
# qualified module names, as well as Unix pattern matching.
ignored-modules=

# List of classes names for which member attributes should not be checked (useful for classes with attributes
# dynamically set). This supports can work with qualified names.
ignored-classes=

# List of members which are set dynamically and missed by pylint inference system, and so shouldn't trigger E1101 when
# accessed. Python regular expressions are accepted.
generated-members=numpy.*, torch.*

[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=_$|dummy

# List of additional names supposed to be defined in builtins. Remember that you should avoid to define new builtins
# when possible.
additional-builtins=

# List of strings which can identify a callback function by name. A callback name must start or end with one of those
# strings.
callbacks=cb_,_cb


[SIMILARITIES]

# Minimum lines number of a similarity.
min-similarity-lines=4

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

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

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


[SPELLING]

# Spelling dictionary name. Available dictionaries: none. To make it working install python-enchant package.
spelling-dict=

# List of comma separated words that should not be checked.
spelling-ignore-words=

# A path to a file that contains private dictionary; one word per line.
spelling-private-dict-file=

# Tells whether to store unknown words to indicated private dictionary in --spelling-private-dict-file option instead of
# raising a message.
spelling-store-unknown-words=no


[MISCELLANEOUS]

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


[BASIC]

# List of builtins function names that should not be used, separated by a comma
bad-functions=map,filter,input

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

# Bad variable names which should always be refused, separated by a comma
bad-names=foo,bar,baz,toto,tutu,tata

# Colon-delimited sets of names that determine each other's naming style when
# the name regexes allow several styles.
name-group=

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

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

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

# 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_]{0,30}$

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

# Regular expression which should only match function or class names that do not require a docstring.
no-docstring-rgx=^_

# Minimum line length for functions/classes that require docstrings, shorter ones are exempt.
docstring-min-length=-1


[ELIF]

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


[IMPORTS]

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

# Create a graph of every (i.e. internal and external) dependencies in the given file (report RP0402 must not be
# disabled)
import-graph=

# Create a graph of external dependencies in the given file (report RP0402 must not be disabled)
ext-import-graph=

# Create a graph of internal dependencies in the given file (report RP0402 must not be disabled)
int-import-graph=


[DESIGN]

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

# Argument names that match this expression will be ignored. Default to name with leading underscore
ignored-argument-names=_.*

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

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

# Maximum number of branch for function / method body
max-branches=24

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

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

# Maximum number of attributes for a class (see R0902).
max-attributes=14

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

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

# Maximum number of boolean expressions in a 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