Skip to content

Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.

24.3 KB
Raw Blame
[project]
name = "pipelex"
version = "0.93.1"
description = "Execute composable AI methods declared in the MTHDS open standard"
authors = [{ name = "Evotis S.A.S.", email = "[email protected]" }]
maintainers = [{ name = "Pipelex staff", email = "[email protected]" }]
license = "Elastic-2.0"
license-files = ["LICENSE"]
readme = "README.md"
requires-python = ">=3.11,<3.15"
classifiers = [
  "Programming Language :: Python :: 3",
  "Programming Language :: Python :: 3.11",
  "Programming Language :: Python :: 3.12",
  "Programming Language :: Python :: 3.13",
  "Programming Language :: Python :: 3.14",
  "Operating System :: OS Independent",
]

dependencies = [
  "aiofiles>=23.2.1",
  # The migration fingerprint reads constraint objects from it by type. A zero-dependency
  # interchange vocabulary, declared directly rather than borrowed from pydantic's own tree.
  "annotated-types>=0.7.0",
  "datamodel-code-generator>=0.55.0",
  "filetype>=1.2.0",
  "httpx>=0.23.0,<1.0.0",
  "idna>=3.15",
  "instructor>=1.17.0,<2.0.0",                      # 1.16+ supports mistralai 2.x; 2.0 is a planned major we have not assessed
  "jinja2>=3.1.6,<3.2",
  "json2html>=1.3.0",
  "kajson==0.7.1",
  "markdown-it-py[linkify]>=3.0.0",                 # the Markdown concept, the `markdown` filter and the built-in PDF engine
  "mthds==0.25.0",
  "networkx>=3.4.2",
  "openai>=2.0.0",
  "packaging>=24.0",                                # reads a method's requirements.txt: PEP 508 requirements, markers and versions
  "opentelemetry-api>=1.39.0",
  "opentelemetry-exporter-otlp-proto-http>=1.38.0",
  "opentelemetry-semantic-conventions>=0.59b0",
  "opentelemetry-sdk>=1.39.0",                      # 1.39+ exports InMemoryLogRecordExporter, which the otlp sink's tests use
  "pillow>=12.1.1",
  "pipelex-tools-py>=0.1.3",
  # The client for the hosted Pipelex API, behind hosted runs (pipelex/hosted/). Pinned exactly, like
  # mthds: each pipelex-sdk release pins mthds exactly too, so the release chosen here must pin the
  # same mthds as this file, and the two pins move together (the bump-mthds skill says so).
  "pipelex-sdk==0.53.0",
  "polyfactory>=2.21.0",
  "portkey-ai>=2.1.0",
  "posthog>=6.7.0",
  "protobuf>=6.33.5",
  "pypdfium2>=4.30.0,!=4.30.1,<5.0.0",
  "pydantic>=2.10.6,<3.0.0",
  "python-dotenv>=1.2.2",
  "PyYAML>=6.0.2",
  "reportlab>=4.0,<5",                 # the built-in PDF engine of PipeDocGen, and synthetic PDFs in tests
  "requests>=2.33.0",
  "semantic-version>=2.10.0",
  "shortuuid>=1.0.13",
  # Not stdlib tomllib: our error path reads TOMLDecodeError.{msg,doc,pos,lineno,colno},
  # which tomli exposes on every supported Python but stdlib tomllib only gained in 3.14.
  "tomli>=2.3.0",
  "tomlkit>=0.13.2",
  # Capped: pipelex subclasses typer's TyperGroup and overrides make_context, so
  # it is coupled to typer/click internals. Tested through 0.26; the dependency
  # canary flags new releases to validate before raising this bound.
  "typer>=0.16.0,<0.27",
  "typing-extensions>=4.13.2",
  "urllib3>=2.7.0",
]

[project.urls]
Homepage = "https://pipelex.com"
Repository = "https://github.com/Pipelex/pipelex"
Documentation = "https://docs.pipelex.com/"
Changelog = "https://docs.pipelex.com/changelog/"
"MTHDS Standard" = "https://mthds.ai/latest/"

[project.optional-dependencies]
anthropic = ["anthropic>=0.78.0"]
bedrock = ["boto3>=1.42.42", "aiobotocore>=3.0.0"]
# Rich renders the terminal: the `pipelex` and `pipelex-agent` CLIs, the console log sink and the
# pretty-print mode "rich". Nothing the runtime does on the way to running a method needs it, so a
# server selects the json sink and a Rich-free pretty-print mode and never reaches for it. Leaving this
# extra out does not make the environment Rich-free, though: `typer` and `instructor` are core
# dependencies and both require Rich unconditionally, so a stock install still contains it.
cli = ["rich>=13.8.1"]
docling = [
  "docling>=2.94.0",
  "lxml>=6.1.0",
]
fal = ["fal-client>=0.4.1"]
gcp-logging = ["google-cloud-logging>=3.12.0"]
gcp-storage = [
  "google-cloud-storage>=2.10.0",
  "cryptography>=46.0.7",
]
google = [
  "google-auth-oauthlib>=1.2.1",
  "cryptography>=46.0.7",
]
google-genai = [
  "google-genai",
  "instructor[google-genai]",
  "cryptography>=46.0.7",
]
huggingface = ["huggingface_hub>=1.5.0,<2.0.0"]
linkup = ["linkup-sdk>=0.12.0"]
mistralai = ["mistralai>=2.10.0"]
dynamodb = ["boto3>=1.34.131"]
s3 = ["boto3>=1.42.42", "aiobotocore>=3.0.0"]
docs = [
  "mike>=2.1.3",
  "mkdocs>=1.6.1,<2",
  "mkdocs-glightbox>=0.4.0",
  "mkdocs-material>=9.7.7",
  "mkdocs-meta-manager>=1.1.0",
  "mkdocs-redirects==1.2.2",
  "mkdocs-llmstxt-md>=0.2.0",
  "Pygments>=2.20.0",
  "pymdown-extensions>=10.21.3",
]

dev = [
  "boto3-stubs>=1.35.24",
  "cryptography>=46.0.7",
  "hypothesis>=6.140.3",
  "jsonschema>=4.20.0",
  "moto[dynamodb,s3]>=5.0.0",
  "mypy==1.19.1",
  "pipelex-tools>=0.7.2",
  "pyright==1.1.411",
  "pylint==4.0.4",
  "pytest>=9.0.3",
  "pytest-asyncio>=0.24.0",
  "pytest-cov>=6.1.1",
  "pytest-mock>=3.14.0",
  "pytest-sugar>=1.0.0",
  "pytest-timeout>=2.3.1",
  "pytest-split>=0.10.0",
  "pytest-xdist>= 3.6.1",
  "ruff==0.16.4",
  "types-aiobotocore[bedrock,bedrock-runtime]>=3.0.0",
  "types-aiofiles>=24.1.0.20240626",
  "types-jsonschema>=4.20.0",
  "types-networkx>=3.3.0.20241020",
  "types-PyYAML>=6.0.12.20250326",
]
typesafe = [
  "typesafe-sdk>=0.7.0",
]

[project.scripts]
pipelex = "pipelex.cli._cli:app"
pipelex-agent = "pipelex.cli.agent_cli._agent_cli:app"
pipelex-dev = "pipelex.cli.dev_cli._dev_cli:app"

[build-system]
requires = ["hatchling>=1.27"]
build-backend = "hatchling.build"

[tool.mypy]
check_untyped_defs = true
exclude = ["^.*\\.venv/.*$"]
mypy_path = "."
packages = ["pipelex", "tests"]
plugins = ["pydantic.mypy"]
python_version = "3.11"
warn_return_any = true
warn_unused_configs = true

[[tool.mypy.overrides]]
ignore_missing_imports = true
module = [
  "filetype",
  "json2html",
  "pypdfium2",
  "pypdfium2.raw",
]

[tool.pyright]
venvPath = "."
venv = ".venv"
pythonVersion = "3.11"
include = ["pipelex", "tests"]
exclude = [
  "**/__pycache__",
  ".venv",
  ".git",
  "build",
  "dist",
  "**/node_modules",
  "**/.*",
]
analyzeUnannotatedFunctions = true
deprecateTypingAliases = false
disableBytesTypePromotions = true
enableExperimentalFeatures = false
enableTypeIgnoreComments = true
extraPaths = ["./tests"]
reportAbstractUsage = "error"
reportArgumentType = "error"
reportAssertAlwaysTrue = "error"
reportAssertTypeFailure = "error"
reportAssignmentType = "error"
reportAttributeAccessIssue = "error"
reportCallInDefaultInitializer = true
reportCallIssue = "error"
reportConstantRedefinition = "error"
reportDeprecated = "error"
reportDuplicateImport = "error"
reportFunctionMemberAccess = "error"
reportGeneralTypeIssues = "error"
reportImplicitOverride = true
reportImplicitStringConcatenation = false
reportImportCycles = true
reportIncompatibleMethodOverride = "error"
reportIncompatibleVariableOverride = "error"
reportIncompleteStub = "error"
reportInconsistentConstructor = "error"
reportInconsistentOverload = "error"
reportIndexIssue = "error"
reportInvalidStringEscapeSequence = "error"
reportInvalidStubStatement = "error"
reportInvalidTypeArguments = "error"
reportInvalidTypeForm = "error"
reportInvalidTypeVarUse = "error"
reportMatchNotExhaustive = "error"
reportMissingImports = "error"
reportMissingModuleSource = "warning"
reportMissingParameterType = "error"
reportMissingSuperCall = "none"
reportMissingTypeArgument = "error"
reportMissingTypeStubs = false
reportNoOverloadImplementation = "error"
reportOperatorIssue = "error"
reportOptionalCall = "error"
reportOptionalContextManager = "error"
reportOptionalIterable = "error"
reportOptionalMemberAccess = "error"
reportOptionalOperand = "error"
reportOptionalSubscript = "error"
reportOverlappingOverload = "error"
reportPossiblyUnboundVariable = "error"
reportPrivateImportUsage = "error"
reportPrivateUsage = "error"
reportPropertyTypeMismatch = true
reportRedeclaration = "error"
reportReturnType = "error"
reportSelfClsParameterName = "error"
reportTypeCommentUsage = "error"
reportTypedDictNotRequiredAccess = "error"
reportUnboundVariable = "error"
reportUndefinedVariable = "error"
reportUninitializedInstanceVariable = "none"
reportUnknownArgumentType = "error"
reportUnknownLambdaType = "error"
reportUnknownMemberType = "error"
reportUnknownParameterType = "error"
reportUnknownVariableType = "error"
reportUnnecessaryCast = "error"
reportUnnecessaryComparison = "error"
reportUnnecessaryContains = "error"
reportUnnecessaryIsInstance = "error"
reportUnnecessaryTypeIgnoreComment = "none"
reportUnsupportedDunderAll = "error"
reportUntypedBaseClass = "error"
reportUntypedClassDecorator = "error"
reportUntypedFunctionDecorator = "error"
reportUntypedNamedTuple = "error"
reportUnusedCallResult = "none"
reportUnusedClass = "error"
reportUnusedCoroutine = "error"
reportUnusedExcept = "error"
reportUnusedExpression = "error"
reportUnusedFunction = "error"
reportUnusedImport = "none"
reportUnusedVariable = "error"
reportWildcardImportFromLibrary = "error"
strictDictionaryInference = true
strictListInference = true
strictParameterNoneValue = true
strictSetInference = true
typeCheckingMode = "strict"

[tool.pytest]
minversion = "9.0"
# All tests live under tests/ — this keeps bare `pytest` runs from scanning the whole repo (and from
# ever collecting a stray root-level `build/` artifact tree, since `build` is removed from norecursedirs below).
testpaths = ["tests"]
# pytest's default norecursedirs includes `build`, which silently skipped every test under
# tests/unit/pipelex/cli/commands/build/ (mirroring the source layout). Override = defaults minus `build`.
norecursedirs = [
  "*.egg",
  ".*",
  "_darcs",
  "CVS",
  "dist",
  "node_modules",
  "venv",
  "{arch}",
]
addopts = [
  "--import-mode=importlib",
  "-ra",                                                                               # Show all test outcomes (including skips)
  "-m",
  "not (inference or llm or img_gen or extract or search or judgment or pipelex_api)",
]
asyncio_default_fixture_loop_scope = "session"
xfail_strict = true
filterwarnings = [
  "ignore:Support for class-based `config` is deprecated:DeprecationWarning",
  "ignore:websockets.*is deprecated:DeprecationWarning",
  "ignore:typing\\.io is deprecated:DeprecationWarning",
  "ignore:typing\\.re is deprecated:DeprecationWarning",
  "ignore:.*has been moved to cryptography.*",
  "ignore:Use.*Types instead",
]
markers = [
  "inference: slow and costly due to inference calls",
  "llm: slow and costly due to llm inference calls",
  "img_gen: slow and costly due to image generation inference calls",
  "extract: slow and costly due to doc extraction inference calls",
  "search: slow and costly due to search inference calls",
  "judgment: slow and costly due to judgment inference calls",
  "gha_disabled: tests that should not run in GitHub Actions",
  "codex_disabled: tests that should not run in Codex",
  "dry_runnable: tests that can be run in dry-run mode",
  "pipelex_api: tests that require access to the Pipelex API",
  "builds_problems_without_required_params(reason): the test builds a problem lacking a parameter its code requires on purpose, which the sweep of tests/unit/conftest.py otherwise fails",
]

[tool.coverage.run]
source = ["pipelex"]
omit = ["tests/*", "**/__init__.py"]

[tool.coverage.report]
exclude_lines = [
  "pragma: no cover",
  "def __repr__",
  "raise NotImplementedError",
  "if __name__ == .__main__.:",
  "pass",
  "raise ImportError",
]

[tool.ruff]
exclude = [
  # The `api/` workspace member runs ruff under its own configuration (`make -C api agent-check`).
  "api",
  ".cursor",
  ".git",
  ".github",
  ".mypy_cache",
  ".ruff_cache",
  ".venv",
  ".vscode",
  "trigger_pipeline",
]
line-length = 150
target-version = "py311"

[tool.ruff.format]

[tool.ruff.lint]
preview = true
select = ["ALL"]
ignore = [
  "missing-return-type-undocumented-public-function", # Missing return type annotation for public function `my_func`
  "missing-return-type-private-function",             # Missing return type annotation for private function `my_func`
  "missing-return-type-special-method",               # Missing return type annotation for special method `my_func`
  "missing-return-type-class-method",                 #  Missing return type annotation for classmethod `my_func`
  "any-type",                                         # Dynamically typed expressions (typing.Any) are disallowed in `...`
  "blocking-open-call-in-async-function",             # Async functions should not open files with blocking methods like `open`
  "blocking-path-method-in-async-function",           # Async functions should not use pathlib.Path methods, use trio.Path or anyio.path

  "class-as-data-structure", # Class could be dataclass or namedtuple

  "complex-structure",      # Is to complex
  "missing-trailing-comma", # Checks for the absence of trailing commas.

  "missing-copyright-notice", # Missing copyright notice at top of file

  "undocumented-public-module",          # Missing docstring in public module
  "undocumented-public-class",           # Missing docstring in public class
  "undocumented-public-method",          # Missing docstring in public method
  "undocumented-public-function",        # Missing docstring in public function
  "undocumented-public-package",         # Missing docstring in public package
  "undocumented-magic-method",           # Missing docstring in magic method
  "undocumented-public-init",            # Missing docstring in __init__
  "missing-blank-line-after-summary",    # 1 blank line required between summary line and description
  "missing-trailing-period",             # First line should end with a period
  "non-imperative-mood",                 # First line of docstring should be in imperative mood: "My docstring...."
  "docstring-starts-with-this",          # First word of the docstring should not be "This"
  "property-docstring-starts-with-verb", # Our property docstrings read as noun phrases describing the value ("The resolved config."), which is how they render in reference docs
  "missing-terminal-punctuation",        # First line should end with a period, question mark, or exclamation point

  "docstring-missing-returns",      # `return` is not documented in docstring
  "docstring-extraneous-returns",   # Docstring should not have a returns section because the function doesn't return anything
  "docstring-missing-yields",       # `yield` is not documented in docstring
  "docstring-extraneous-exception", # Raised exception is not explicitly raised: `FileNotFoundError`
  "docstring-missing-exception",    # Raised exception `ModuleFileError` missing from docstring

  "call-datetime-without-tzinfo",     # `datetime.datetime()` called without a `tzinfo` argument
  "call-datetime-now-without-tzinfo", # `datetime.datetime.now()` called without a `tz` argument

  "commented-out-code", # Found commented-out code

  "boolean-type-hint-positional-argument",     # Boolean-typed positional argument in function definition
  "boolean-default-value-positional-argument", # Boolean default positional argument in function definition
  "boolean-positional-value-in-call",          #Boolean positional value in function call

  "line-contains-todo", # Line contains TODO, consider resolving the issue

  "read-whole-file", # `open` and `read` should be replaced by `Path(file_path.path).read_text(encoding="utf-8")`
  "repeated-append", # Checks for consecutive calls to append.
  "math-constant",   # Checks for literals that are similar to constants in math module.

  "log-exception-outside-except-handler", # `.exception()` call outside exception handlers

  "type-name-incorrect-variance", # `TypeVar` name "SomethingType" does not reflect its covariance; consider renaming it to "SomethingType_co"
  "compare-to-empty-string",      # Checks for comparisons to empty strings.

  "too-many-public-methods",           # Too many public methods ( > 20)
  "too-many-return-statements",        # Too many return statements (/6)
  "too-many-branches",                 # Too many branches (/12)
  "too-many-arguments",                # Too many arguments in function definition (/5)
  "too-many-locals",                   # Too many local variables ( /15)
  "too-many-statements",               # Too many statements (/50)
  "too-many-positional-arguments",     # Too many positional arguments ( /5)
  "magic-value-comparison",            # Magic value used in comparison, consider replacing `2` with a constant variable
  "no-self-use",                       # Too many return statements in `for` loop
  "too-many-nested-blocks",            # Too many nested blocks ( > 5)
  "too-many-statements-in-try-clause", # Shrinking an existing try clause changes which statements are covered by its handlers: an error-handling refactor, not lint cleanup

  "pytest-incorrect-pytest-import", # Incorrect import of `pytest`; use `import pytest` instead

  "os-path-abspath",  # `os.path.abspath()` should be replaced by `Path.resolve()`
  "os-makedirs",      # `os.makedirs()` should be replaced by `Path.mkdir(parents=True)`
  "os-remove",        # `os.remove()` should be replaced by `Path.unlink()`
  "os-getcwd",        # `os.getcwd()` should be replaced by `Path.cwd()`
  "os-path-join",     # `os.path.join()` should be replaced by `Path` with `/` operator
  "os-path-dirname",  # `os.path.dirname()` should be replaced by `Path.parent`
  "os-path-exists",   # `os.path.exists()` should be replaced by `Path.exists()`
  "os-path-isdir",    # `os.path.isdir()` should be replaced by `Path.is_dir()`
  "os-path-basename", # `os.path.basename()` should be replaced by `Path.name`
  "builtin-open",     # `open()` should be replaced by `Path.open()`
  "os-listdir",       # Use `pathlib.Path.iterdir()` instead.

  "redundant-literal-union", # `Literal["auto"]` is redundant in a union with `str`

  "superfluous-else-return", # superfluous-else-return

  "ambiguous-unicode-character-string",  # String contains ambiguous `′` (PRIME). Did you mean ``` (GRAVE ACCENT)?
  "ambiguous-unicode-character-comment", # Comment contains ambiguous `’` (RIGHT SINGLE QUOTATION MARK). Did you mean ``` (GRAVE ACCENT)?
  "unsorted-dunder-all",                 # Checks for __all__ definitions that are not ordered according to an "isort-style" sort.

  "suppressible-exception",          # Use `contextlib.suppress(ValueError)` instead of `try`-`except`-`pass`
  "if-else-block-instead-of-if-exp", # Use ternary operator `description = func.__doc__.strip().split("\n")[0] if func.__doc__ else func.__name__` instead of `if`-`else`-block

  "assert",                      # Use of `assert` detected
  "exec-builtin",                # Use of `exec` detected
  "hardcoded-password-func-arg", # Possible hardcoded password assigned to argument: "secret"
  "hardcoded-password-string",   # Possible hardcoded password assigned to: "child_secret"

  "suspicious-non-cryptographic-random-usage", # Cryptographically weak pseudo-random number generator

  "missing-todo-author", # Missing author in TODO; try: `# TODO(<author_name>): ...` or `# TODO @<author_name>: ...`
  "missing-todo-link",   # Missing issue link for this TODO

  "print", # `print` found

  # TODO: stop ignoring these rules
  "empty-method-without-abstract-decorator", # Checks for empty methods in abstract base classes without an abstract decorator.
  "non-pep604-annotation-union",             # Use `X | Y` for type annotations
  "outdated-version-block",                  # Version block is outdated for minimum Python version
  "collapsible-if",                          # Use a single `if` statement instead of nested `if` statements
  "jinja2-autoescape-false",                 # Using jinja2 templates with `autoescape=False` is dangerous and can lead to XSS. Ensure `autoescape=True` or use the `select_autoescape` function.
  "raise-within-try",                        # Abstract `raise` to an inner function
  "manual-list-comprehension",               # Use a list comprehension to create a transformed list
  "redefined-loop-name",                     # `for` loop variable `line` overwritten by assignment target
  "try-consider-else",                       # Consider moving this statement to an `else` block
  "deprecated-import",                       # `typing.List` is deprecated, use `list` instead
  "implicit-return",                         # Missing explicit `return` at the end of function able to return non-`None` value
]

[tool.ruff.lint.pydocstyle]
convention = "google"

[tool.ruff.lint.flake8-type-checking]
# Pydantic resolves annotations at runtime to build validators, so an annotation-only import that
# TC00x moves into an `if TYPE_CHECKING:` block breaks the model. These bases mark the classes whose
# annotations are runtime-evaluated. This is also the setting consumers of `pipelex codegen types`
# need for the generated artifacts — see docs/under-the-hood/codegen-projections.md.
runtime-evaluated-base-classes = [
  "pydantic.BaseModel",
  "pipelex.core.stuffs.structured_content.StructuredContent",
  "pipelex.system.configuration.config_model.ConfigModel",
  "pipelex.system.configuration.config_root.ConfigRoot",
]

[tool.ruff.lint.flake8-tidy-imports]
# Rich is the `cli` extra, so outside the CLI it is imported inside the function that renders, never at
# module level. Listing it here is also what lets such a deferred import stand without an
# `import-outside-top-level` suppression. The authoritative gate is `make check-rich-imports`, which applies
# the same allowlist and also sees an import in a module-level `try` block or class body; the per-file
# ignore for `pipelex/cli/` below mirrors its allowlist.
banned-module-level-imports = ["rich"]

[tool.ruff.lint.per-file-ignores]
"tests/**/*.py" = [
  "implicit-namespace-package",  # Allow test files to not have __init__.py in their directories (avoids namespace collisions)
  "blind-except",                # Broad `except Exception` is acceptable in tests (asserting failure modes, defensive fixtures)
  "float-equality-comparison",   # Tests assert exact float literals that round-trip exactly; `pytest.approx` would only add noise
  "import-private-name",         # Tests reach into private `_core` modules on purpose, to exercise the logic behind a CLI command without going through the CLI
  "banned-module-level-imports", # The test suite installs every extra, the `cli` extra's Rich included
]
# The CLI installs the `cli` extra: the check-rich-imports guard's allowlist.
"pipelex/cli/**/*.py" = ["banned-module-level-imports"]

# The usage example in `needs_inference_in_pipelex` is a pytest fixture, so it contains a bare `yield`
# line. Ruff's Google-style parser reads any line starting with `yield` as a section header, wherever it
# is indented, and its autofixes then rewrite it into a literal `Yield:` section that breaks the example.
# The diagnostics land inside the docstring body, so no suppression comment can reach them.
"pipelex/test_extras/shared_pytest_plugins.py" = [
  "incorrect-section-order",
  "overindented-section",
  "non-capitalized-section-name",
  "missing-section-name-colon",
]

[tool.uv]
required-version = ">=0.7.2"

# The Pipelex API server lives in `api/` as a second workspace member, the `pipelex-api` distribution.
# It depends on this package through the workspace, so it always runs the library of the same commit,
# and the repository keeps one `uv.lock`. Nothing of it reaches the `pipelex` wheel or sdist, which
# the hatch targets below restrict to `packages = ["pipelex"]`. See `api/CLAUDE.md`.
[tool.uv.workspace]
members = ["api"]


[tool.hatch.build.targets.wheel]
packages = ["pipelex"]
exclude = ["pipelex/cli/dev_cli"]


[tool.hatch.build.targets.sdist]
packages = ["pipelex"]
exclude = ["pipelex/cli/dev_cli"]

[tool.hatch.metadata]
allow-direct-references = true

[tool.pylint.main]
py-version = "3.11"
reports = false

[tool.pylint.messages_control]
disable = ["all"]
enable = [
  "W0101", # Unreachable code: Used when there is some code behind a "return" or "raise" statement, which will never be accessed.
  "C0103", # invalid-name (naming convention)
]
ignore = [".venv", "__pycache__", "build", "dist", ".git"]

[tool.pylint.basic]
# Variables / attributes / arguments: snake_case, not length 1
variable-rgx = "^(?!.$)[a-z_][a-z0-9_]*$"
argument-rgx = "^(?!.$)[a-z_][a-z0-9_]*$"
attr-rgx = "^(?!.$)[a-z_][a-z0-9_]*$"

# Functions / methods: snake_case, not length 1
function-rgx = "^(?!.$)[a-z_][a-z0-9_]*$"
method-rgx = "^(?!.$)[a-z_][a-z0-9_]*$"

# Classes: CapWords, not length 1
class-rgx = "^(?!.$)[A-Z_][a-zA-Z0-9_]*$"
typevar-rgx = "^[A-Za-z_][A-Za-z0-9_]*$"
good-names = ["_"]