From de28c9bb8097b9db81eb5a62e8b11ed434328a1d Mon Sep 17 00:00:00 2001 From: Rohan McGovern Date: Mon, 5 Jul 2021 13:55:07 +1000 Subject: [PATCH] pylint: refactor config to reduce noise This commit inverts the behavior for pylint checks. Previously, we started with all checks enabled and then disabled some we didn't want. Now we'll instead start with all checks *disabled* and enable those we *do* want. The reasons for this include: - pylint output is far too noisy right now, meaning that the output is generally ignored except for errors. It would be good to make it more useful by cutting down on the number of checks. - pylint adds new checks regularly. If all checks are enabled by default, this adds to the maintenance overhead for us to keep our dependencies continuously up-to-date, since it's more likely that a pylint update will require code changes in order to pass CI or to avoid more noise. - the most valuable pylint checks, such as dangerous-default-value, were implemented long ago and are enabled. By comparison, new pylint checks being added these days are more likely to be opinionated recommendations which are less valuable, so we shouldn't lose much by not enabling them by default. --- .pylintrc | 370 +++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 271 insertions(+), 99 deletions(-) diff --git a/.pylintrc b/.pylintrc index a7e288dd..af4371d4 100644 --- a/.pylintrc +++ b/.pylintrc @@ -1,101 +1,273 @@ [MESSAGES CONTROL] -disable=print-statement, - parameter-unpacking, - unpacking-in-except, - old-raise-syntax, - backtick, - long-suffix, - old-ne-operator, - old-octal-literal, - import-star-module-level, - non-ascii-bytes-literal, - invalid-unicode-literal, - raw-checker-failed, - bad-inline-option, - locally-disabled, - locally-enabled, - file-ignored, - suppressed-message, - useless-suppression, - deprecated-pragma, - apply-builtin, - basestring-builtin, - buffer-builtin, - cmp-builtin, - coerce-builtin, - execfile-builtin, - file-builtin, - long-builtin, - raw_input-builtin, - reduce-builtin, - standarderror-builtin, - unicode-builtin, - xrange-builtin, - coerce-method, - delslice-method, - getslice-method, - setslice-method, - no-absolute-import, - old-division, - dict-iter-method, - dict-view-method, - next-method-called, - metaclass-assignment, - indexing-exception, - raising-string, - 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, - using-cmp-argument, - eq-without-hash, - div-method, - idiv-method, - rdiv-method, - exception-message-attribute, - invalid-str-codec, - sys-max-int, - bad-python3-import, - 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, - deprecated-operator-function, - deprecated-urllib-function, - xreadlines-attribute, - deprecated-sys-function, - exception-escape, - comprehension-escape, - #### Additions to defaults start here #### - # not everything needs docs - missing-docstring, - # we still support Python 2 - useless-object-inheritance, - # conflicts with design of attrs-based classes - too-few-public-methods, - no-self-use, - # attrs confuses pylint type inference - not-an-iterable, - # nothing wrong with having TODO or FIXME comments... - fixme, - # some classes have code accessing each other - protected-access, - # false positives on 'staged' backend - unused-private-member, - # we use black code style and don't need additional checks - bad-continuation, - line-too-long, +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, + arguments-renamed, + assert-on-string-literal, + assert-on-tuple, + assign-to-new-keyword, + assigning-non-slot, + assignment-from-no-return, + assignment-from-none, + astroid-error, + attribute-defined-outside-init, + await-outside-async, + bad-classmethod-argument, + bad-except-order, + bad-exception-context, + bad-format-character, + bad-format-string, + bad-format-string-key, + bad-indentation, + bad-mcs-classmethod-argument, + bad-mcs-method-argument, + bad-open-mode, + bad-option-value, + bad-plugin-value, + bad-reversed-sequence, + bad-staticmethod-argument, + bad-str-strip-call, + bad-string-format-type, + bad-super-call, + bad-thread-instantiation, + bare-except, + binary-op-exception, + boolean-datetime, + broad-except, + c-extension-no-member, + catching-non-exception, + cell-var-from-loop, + chained-comparison, + class-variable-slots-conflict, + comparison-with-callable, + comparison-with-itself, + condition-evals-to-constant, + confusing-with-statement, + consider-merging-isinstance, + consider-swap-variables, + consider-using-enumerate, + consider-using-from-import, + consider-using-generator, + consider-using-get, + consider-using-in, + consider-using-join, + consider-using-max-builtin, + consider-using-min-builtin, + consider-using-set-comprehension, + consider-using-sys-exit, + consider-using-ternary, + consider-using-with, + continue-in-finally, + cyclic-import, + dangerous-default-value, + deprecated-argument, + deprecated-class, + deprecated-decorator, + deprecated-method, + deprecated-module, + dict-iter-missing-items, + disallowed-name, + duplicate-argument-name, + duplicate-bases, + duplicate-except, + duplicate-key, + duplicate-string-formatting-argument, + empty-docstring, + eval-used, + exec-used, + expression-not-assigned, + f-string-without-interpolation, + fatal, + format-combined-specification, + format-needs-mapping, + function-redefined, + global-at-module-level, + global-statement, + global-variable-not-assigned, + global-variable-undefined, + implicit-str-concat, + import-error, + import-outside-toplevel, + import-self, + inconsistent-mro, + inconsistent-quotes, + inherit-non-class, + init-is-generator, + invalid-all-format, + invalid-all-object, + invalid-bool-returned, + invalid-bytes-returned, + invalid-characters-in-docstring, + invalid-class-object, + invalid-envvar-default, + invalid-envvar-value, + invalid-format-index, + invalid-format-returned, + invalid-getnewargs-ex-returned, + invalid-getnewargs-returned, + invalid-hash-returned, + invalid-index-returned, + invalid-length-hint-returned, + invalid-length-returned, + invalid-metaclass, + invalid-overridden-method, + invalid-repr-returned, + invalid-sequence-index, + invalid-slice-index, + invalid-slots, + invalid-slots-object, + invalid-star-assignment-target, + invalid-str-returned, + invalid-unary-operand-type, + isinstance-second-argument-not-valid-type, + keyword-arg-before-vararg, + len-as-condition, + literal-comparison, + logging-format-interpolation, + logging-format-truncated, + logging-fstring-interpolation, + logging-not-lazy, + logging-too-few-args, + logging-too-many-args, + logging-unsupported-format, + lost-exception, + method-check-failed, + method-hidden, + misplaced-bare-raise, + misplaced-comparison-constant, + misplaced-format-function, + misplaced-future, + 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-line-endings, + multiple-imports, + multiple-statements, + nan-comparison, + no-classmethod-decorator, + no-else-break, + no-else-continue, + no-else-raise, + no-else-return, + no-init, + no-method-argument, + no-name-in-module, + no-self-argument, + no-staticmethod-decorator, + no-value-for-parameter, + non-ascii-name, + non-iterator-returned, + non-parent-init-called, + non-str-assignment-to-dunder-name, + nonexistent-operator, + nonlocal-and-global, + nonlocal-without-binding, + not-a-mapping, + not-async-context-manager, + not-callable, + not-context-manager, + not-in-loop, + notimplemented-raised, + parse-error, + pointless-statement, + pointless-string-statement, + possibly-unused-variable, + preferred-module, + property-with-parameters, + raise-missing-from, + raising-bad-type, + raising-format-tuple, + raising-non-exception, + redeclared-assigned-name, + 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, + shallow-copy-environ, + signature-differs, + simplifiable-condition, + 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, + #super-with-arguments, # enable when py2 dropped + superfluous-parens, + syntax-error, + too-few-format-args, + 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-dict-index-lookup, + unnecessary-lambda, + unnecessary-pass, + unnecessary-semicolon, + unneeded-not, + 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-a-generator, + use-maxsplit-arg, + used-before-assignment, + used-prior-global-declaration, + useless-else-on-loop, + useless-import-alias, + useless-return, + useless-super-delegation, + using-constant-test, + wildcard-import, + wrong-exception-operation, + wrong-import-order, + wrong-import-position, + wrong-spelling-in-comment, + wrong-spelling-in-docstring, + yield-inside-async-function, + yield-outside-function,