.pylintrc

#
# Since this is used by CI, this should enable only errors, which can gate
# commit.  That means anything that may have false positives should be omitted,
# unless the false positives are rare and the lint is valuable, in which case
# people have to disable with a pragma in the source (see
# http://pylint.pycqa.org/en/latest/user_guide/message-control.html).
#
# This is intended to be PEP 8: https://www.python.org/dev/peps/pep-0008/

[MASTER]

# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
# number of processors available to use.
jobs = 0

# Control the amount of potential inferred values when inferring a single
# object. This can help the performance when dealing with large functions or
# complex, nested conditions.
limit-inference-results = 100

# Pickle collected data for later comparisons.
persistent = no

# When enabled, pylint would attempt to guess common misconfiguration and emit
# user-friendly hints instead of false-positive error messages.
suggestion-mode = yes

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

[MESSAGES CONTROL]

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

disable = all

# These categories are documented at:
# https://pylint.readthedocs.io/en/latest/technical_reference/features.html
#
# Pylint doesn't let us subtract from 'enable', so if we don't want something
# in a category, we have to first expand it.  I put them in the same order as
# the documentation page, for easier reference.  The documentation order is
# by priority: Error, Warning, Refactor, Convention.
enable =
  ### basic: naming, errors, etc:
  not-in-loop,
  function-redefined,
  continue-in-finally,
  abstract-class-instantiated,
  star-needs-assignment-target,
  duplicate-argument-name,
  return-in-init,
  too-many-star-expressions,
  nonlocal-and-global,
  used-prior-global-declaration,
  return-outside-function,
  return-arg-in-generator,
  invalid-star-assignment-target,
  bad-reversed-sequence,
  nonexistent-operator,
  yield-outside-function,
  init-is-generator,
  misplaced-format-function,
  nonlocal-without-binding,
  lost-exception,
  assert-on-tuple,
  assert-on-string-literal,
  self-assigning-variable,
  comparison-with-callable,
  dangerous-default-value,
  duplicate-key,
  useless-else-on-loop,
  expression-not-assigned,
  confusing-with-statement,
  unnecessary-lambda,
  assign-to-new-keyword,
  redeclared-assigned-name,
  pointless-statement,
  pointless-string-statement,
  unnecessary-pass,
  unreachable,
  eval-used,
  exec-used,
  # using-constant-test, # e.g. if True, but it's useful to comment out
  missing-parentheses-for-call-in-test,
  literal-comparison,
  comparison-with-itself,
  non-ascii-name,
  invalid-name,
  # blacklisted-name, # nothing to blacklist
  # misplaced-comparison-constant, # doesn't like '1 < var', but that's fine
  singleton-comparison,
  empty-docstring,
  missing-class-docstring,
  missing-function-docstring,
  # missing-module-docstring, # leads to silly dummy module docstrings
  unidiomatic-typecheck,

  ### classes
  # Random class-oriented checks:
  # Some of them are advice, e.g. no-self-use, and should probably be omitted.
  access-member-before-definition,
  method-hidden,
  assigning-non-slot,
  duplicate-bases,
  inconsistent-mro,
  inherit-non-class,
  invalid-slots,
  invalid-slots-object,
  no-method-argument,
  no-self-argument,
  unexpected-special-method-signature,
  class-variable-slots-conflict,
  non-iterator-returned,
  invalid-length-returned,
  protected-access,
  attribute-defined-outside-init,
  no-init,
  abstract-method,
  invalid-overridden-method,
  arguments-differ,
  signature-differs,
  bad-staticmethod-argument,
  useless-super-delegation,
  non-parent-init-called,
  super-init-not-called,
  property-with-parameters,
  useless-object-inheritance,
  no-classmethod-decorator,
  no-staticmethod-decorator,
  # no-self-use, # this is design advice
  single-string-used-for-slots,
  bad-classmethod-argument,
  bad-mcs-classmethod-argument,
  bad-mcs-method-argument,
  method-check-failed,

  ### design
  # omitted, it's just arbitrary limits

  ### exceptions
  bad-except-order,
  catching-non-exception,
  bad-exception-context,
  notimplemented-raised,
  raising-bad-type,
  raising-non-exception,
  misplaced-bare-raise,
  duplicate-except,
  broad-except,
  raising-format-tuple,
  binary-op-exception,
  wrong-exception-operation,
  bare-except,
  try-except-raise,

  ### format
  # Line length, indentation, whitespace:
  bad-indentation,
  mixed-indentation,
  unnecessary-semicolon,
  bad-whitespace,
  missing-final-newline,
  line-too-long,
  mixed-line-endings,
  multiple-statements,
  # too-many-lines, # limit on total module size, not pep8
  trailing-newlines,
  trailing-whitespace,
  unexpected-line-ending-format,
  superfluous-parens,
  # bad-continuation, # pylint wants vertical line-up, but that's not pep8

  ### imports
  # import *, relative imports, etc.  The stuff with import order is probably
  # sketchy and will have to be removed.
  import-error,
  # relative-beyond-top-level, # pylint doesn't recognize our packages
  import-self,
  preferred-module,
  reimported,
  relative-import,
  deprecated-module,
  wildcard-import,
  misplaced-future,
  cyclic-import,
  wrong-import-order,
  wrong-import-position,
  useless-import-alias,
  ungrouped-imports,
  multiple-imports,

  # omit 'logging', it's advice for the standard logging module
  # omit 'python3', we already use python3
  # omit 'refactoring', it's arbitrary limits and optional advice
  # omit 'similarities', it's also advice
  # omit 'spelling', it's advice
  # Random stuff which is probably irrelevant but shouldn't hurt:
  stdlib,
  # Format strings.
  string,

  ### typecheck
  # No such variable etc.  These seem useful but might have false positives,
  # disable if it turns out they do.
  unsupported-delete-operation,
  invalid-unary-operand-type,
  unsupported-binary-operation,
  no-member,
  not-callable,
  redundant-keyword-arg,
  assignment-from-no-return,
  assignment-from-none,
  # not-context-manager, # false positives
  unhashable-dict-key,
  repeated-keyword,
  invalid-metaclass,
  missing-kwoa,
  no-value-for-parameter,
  not-an-iterable,
  not-a-mapping,
  invalid-sequence-index,
  invalid-slice-index,
  too-many-function-args,
  unexpected-keyword-arg,
  dict-iter-missing-items,
  unsupported-membership-test,
  unsubscriptable-object,
  keyword-arg-before-vararg,
  non-str-assignment-to-dunder-name,
  arguments-out-of-order,
  isinstance-second-argument-not-valid-type,
  c-extension-no-member,

  ### variables
  # Unused imports, unused variables.
  unpacking-non-sequence,
  invalid-all-object,
  no-name-in-module,
  undefined-variable,
  undefined-all-variable,
  used-before-assignment,
  cell-var-from-loop,
  global-variable-undefined,
  self-cls-assignment,
  unbalanced-tuple-unpacking,
  possibly-unused-variable, # unless locals(), but don't use locals()
  unused-import,
  unused-argument,
  unused-wildcard-import,
  unused-variable,
  global-variable-not-assigned,
  undefined-loop-variable,
  global-at-module-level,

[REPORTS]

# We want binary yes or no, not a score.
score = no
reports = no

[FORMAT]

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

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

# String used as indentation unit.
indent-string = '    '

# Maximum number of characters on a single line.  pylint has to be looser since
# black doesn't always obey its own limit.  See pyproject.toml.
max-line-length = 100

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

# Allow the body of a class to be on the same line as the declaration if body
# contains single statement.
single-line-class-stmt = no

# 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


[TYPECHECK]

# These checks seem sketchy, disable them if they give false positives.

# List of decorators that produce context managers, such as
# contextlib.contextmanager. Add to this list to register other decorators that
# produce valid context managers.
contextmanager-decorators = contextlib.contextmanager

# 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.
# https://github.com/pytorch/pytorch/issues/701#issuecomment-378048755
generated-members = numpy\..*, torch\..*, transformers.*

# 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

# Tells whether to warn about missing members when the owner of the attribute
# is inferred to be None.  But the inference is buggy, so disable it.
ignore-none = yes

# This flag controls whether pylint should warn about no-member and similar
# checks whenever an opaque object is returned when inferring. The inference
# can return multiple potential results while evaluating a Python object, but
# some branches might not be evaluated, which results in partial inference. In
# that case, it might be useful to still emit no-member and other checks for
# the rest of the inferred objects.
ignore-on-opaque-inference = yes

# List of class names for which member attributes should not be checked (useful
# for classes with dynamically set attributes). This supports the use of
# qualified names.
ignored-classes = optparse.Values, thread._local, _thread._local

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

# Show a hint with possible names when a member name was not found. The aspect
# of finding the hint is based on edit distance.
missing-member-hint = yes

# The minimum edit distance a name should have in order to be considered a
# similar match for a missing member name.
missing-member-hint-distance = 1

# The total number of similar names that should be taken in consideration when
# showing a hint for a missing member.
missing-member-max-choices = 1


[VARIABLES]

# Tells whether unused global variables should be treated as a violation.
allow-global-unused-variables = yes

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

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

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


[BASIC]

# Colon-delimited sets of names that determine each other's naming style when
# the name regexes allow several styles.
#
# This doesn't actually work like the documentation implies, so I still have to
# individually write regexes for each one, but I'll leave it here for
# documentation.
name-group = variable:inlinevar:argument:attr:function:method

# snake_case insists on >2 chars, which is not PEP8, so I write my own regex:
argument-rgx = [a-z0-9_]+
attr-rgx = [a-z0-9_]+
class-attribute-rgx = ([a-z0-9_]+|[A-Z0-9_]+)
function-rgx = [a-z0-9_]+
inlinevar-rgx = [a-z0-9_]+
method-rgx = [a-z0-9_]+
variable-rgx = [a-z0-9_]+

# module-naming-style = snake_case
module-rgx = [a-z0-9_]+
class-rgx = [A-Z_][a-zA-Z0-9]*$

# To pylint, "const" doesn't mean constant, it means "defined at module level
# and not a function or class."  PEP8 says UPPER_CASE for constants, but pylint
# can't tell which is which, so allow both.
const-rgx = ([a-z0-9_]+|[A-Z0-9_]+)

include-naming-hint = yes

# Docstrings not required anywhere.
no-docstring-rgx = .
# Omit private functions.
# no-docstring-rgx = ^_


[CLASSES]

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

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

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


[IMPORTS]

# Allow wildcard imports from modules that define __all__.
allow-wildcard-with-all = no

# Analyse import fallback blocks. This can be used to support both Python 2 and
# 3 compatible code, which means that the block might have code that exists
# only in one or another interpreter, leading to false positives when analysed.
analyse-fallback-blocks = no

# Deprecated modules which should not be used, separated by a comma.
deprecated-modules = optparse,tkinter.tix

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

# 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 internal dependencies in the given file (report RP0402 must
# not be disabled).
int-import-graph =

# Force import order to recognize a module as part of the standard
# compatibility libraries.
known-standard-library =

# Force import order to recognize a module as part of a third party library.
known-third-party =


[EXCEPTIONS]

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