pyproject.toml

[build-system]
build-backend = "setuptools.build_meta"
requires = [
  "setuptools",
  "wheel",
  "Cython (>=0.29.12)",
  "jinja2",
  "markupsafe (<2.1)",
  "pyarrow (>=1.0,<3.0.dev)",
  "numpy",
  "packaging",
  "pybind11 (>=2.6)",
]

[tool.black]
line-length = 120

[tool.isort]
profile = "black"
line_length = 120

[tool.pydocstyle]
convention = "google"
match = "(?!python/test).*"
add-ignore = "D105"

[tool.pylint.format]
max-line-length = 120

[tool.pylint.messages_control]
disable = "all"

# We have less surprises when opting in to linting rules than opting out of
# them, but it easier to describe what a rule set by what we want to disable.
# When updating messages, uncomment the below but update the `enable` key
# with the output of `pylint --list-msgs-enabled`
#
# disable = [
#   # TODO(ddn): Should re-enable at some point
#   "missing-function-docstring",
#   "missing-class-docstring",
#   "missing-module-docstring",
#   "unused-wildcard-import",
#   "wildcard-import",
#
#   # Allow linting without all modules being present
#   "import-error",
#   "no-name-in-module",
#   "no-member",
#    "c-extension-no-member",
#
#   "useless-super-delegation",
#
#   # Disable warnings on advanced but required features
#   "no-value-for-parameter",   # False positives on decorators
#   "exec-used",  # It is used
#   "class-variable-slots-conflict",
#   "import-outside-toplevel",  # We need conditional imports
#   "unused-import",            # Some imports have important side-effects
#
#   # Too proscriptive
#   "bad-option-value",      # Tolerate different versions of pylint
#   "fixme",
#   "invalid-name",          # Rules out single letter names
#   "logging-fstring-interpolation",
#   "protected-access",
#   "redefined-builtin",     # Rules out dir and file as names
#   "redefined-outer-name",  # Rules out local variable shadowing a function name
#   "too-few-public-methods",
#   "too-many-ancestors",
#   "too-many-arguments",
#   "too-many-branches",
#   "too-many-locals",
#   "too-many-statements",
#
#   # Conflicts with isort
#   "wrong-import-order",
#   "wrong-import-position",
# ]
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-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",
  "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-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",
  "catching-non-exception",
  "cell-var-from-loop",
  "chained-comparison",
  "comparison-with-callable",
  "comparison-with-itself",
  "condition-evals-to-constant",
  "confusing-with-statement",
  "consider-iterating-dictionary",
  "consider-merging-isinstance",
  "consider-swap-variables",
  "consider-using-dict-comprehension",
  "consider-using-enumerate",
  "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-method",
  "deprecated-module",
  "dict-iter-missing-items",
  "disallowed-name",
  "duplicate-argument-name",
  "duplicate-bases",
  "duplicate-code",
  "duplicate-except",
  "duplicate-key",
  "duplicate-string-formatting-argument",
  "empty-docstring",
  "eval-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-self",
  "inconsistent-mro",
  "inconsistent-quotes",
  "inconsistent-return-statements",
  "inherit-non-class",
  "init-is-generator",
  "invalid-all-object",
  "invalid-bool-returned",
  "invalid-bytes-returned",
  "invalid-characters-in-docstring",
  "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",
  "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",
  "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-self-argument",
  "no-self-use",
  "no-staticmethod-decorator",
  "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-an-iterable",
  "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",
  "redefine-in-handler",
  "redefined-argument-from-local",
  "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",
  "superfluous-parens",
  "syntax-error",
  "too-few-format-args",
  "too-many-boolean-expressions",
  "too-many-format-args",
  "too-many-function-args",
  "too-many-instance-attributes",
  "too-many-lines",
  "too-many-nested-blocks",
  "too-many-public-methods",
  "too-many-return-statements",
  "too-many-star-expressions",
  "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-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-variable",
  "use-a-generator",
  "used-before-assignment",
  "used-prior-global-declaration",
  "useless-else-on-loop",
  "useless-import-alias",
  "useless-object-inheritance",
  "useless-return",
  "using-constant-test",
  "wrong-exception-operation",
  "wrong-spelling-in-comment",
  "wrong-spelling-in-docstring",
  "yield-inside-async-function",
  "yield-outside-function",
]

[tool.pylint.similarities]
min-similarity-lines = 10

[tool.pytest.ini_options]
minversion = "6.0"
addopts = "--import-mode append"