walbox 1.0.0__tar.gz

walbox-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mochama Adriano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

walbox-1.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: walbox
+Version: 1.0.0
+Summary: Async PostgreSQL logical-replication runtime for the transactional outbox pattern
+Keywords: postgresql,logical-replication,outbox,asyncio,cdc,change-data-capture
+Author: Mochama Adriano
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Dist: psycopg>=3.0,<4
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/mochams/walbox
+Project-URL: Documentation, https://mochams.github.io/walbox/
+Project-URL: Repository, https://github.com/mochams/walbox
+Project-URL: Issues, https://github.com/mochams/walbox/issues
+Project-URL: Author, https://github.com/mochams
+Description-Content-Type: text/markdown
+
+# walbox
+
+[![PyPI](https://img.shields.io/pypi/v/walbox.svg)](https://pypi.org/project/walbox/)
+[![CI](https://github.com/mochams/walbox/actions/workflows/ci.yml/badge.svg)](https://github.com/mochams/walbox/actions/workflows/ci.yml)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Async Python runtime for consuming PostgreSQL logical replication as a stream of committed transactions.
+
+**[📖 Documentation](https://mochams.github.io/walbox/) · [⚡ Quickstart](https://mochams.github.io/walbox/getting-started/quickstart/)**
+
+**Some reasons you might want to use walbox:**
+
+- **You want to react to database changes in real time** without polling tables or adding fragile trigger-based workarounds.
+- **You care about reliable delivery**: walbox checkpoints progress durably so it can resume cleanly after restarts or connection drops.
+- **You’re building around the transactional outbox pattern** and want a consumer that preserves commit ordering and handles recovery sensibly.
+- **You want backpressure built in**, so a slow handler does not turn into unbounded memory growth or silent data loss.
+- **You need a Python async consumer** that plugs directly into PostgreSQL logical replication instead of shoving data through a separate broker.
+- **You want to stream changes from published tables** without writing your own replication client, reconnect logic, or checkpoint tracking.
+- **You want operational visibility**: retries, lag, queue depth, and checkpoint timing are all surfaced so production behavior is easier to reason about.
+
+## Guarantees
+
+- **At-least-once delivery**: a durable local checkpoint ensures committed events are not silently skipped
+- **Transactional consistency**: outbox events are committed atomically with your business data
+- **No polling**: consumes changes directly from PostgreSQL logical replication
+- **Bounded backpressure**: queue limits prevent a slow handler from accumulating unbounded memory
+- **Automatic recovery**: resumes from the last durable checkpoint on restart
+- **Graceful shutdown**: lets in-flight work complete before exiting
+- **Asyncio-native**: built for Python's async runtime
+
+## Install
+
+```sh
+pip install walbox
+```
+
+Psycopg 3 is the only Python dependency. By default it uses your system's `libpq`; if you don't have it installed, use the binary distribution: `pip install walbox psycopg[binary]`.
+
+## Example
+
+PostgreSQL setup (one-time):
+
+```sql
+CREATE TABLE outbox (
+    id BIGSERIAL PRIMARY KEY, entity_type TEXT, entity_id TEXT,
+    event_type TEXT, payload JSONB, created_at TIMESTAMPTZ DEFAULT now()
+);
+CREATE PUBLICATION walbox_pub FOR TABLE outbox;
+```
+
+Handler (`handler.py`):
+
+```python
+import asyncio
+from walbox import (
+    ChangeKind,
+    CheckpointHandle,
+    Transaction,
+    Walbox,
+    WalboxOptions,
+)
+
+
+async def handle(tx: Transaction, checkpoint: CheckpointHandle) -> None:
+    for change in tx.changes:
+        if change.table == "public.outbox" and change.kind == ChangeKind.INSERT:
+            print(f"Event: {change.new}")
+    await checkpoint.save(tx.commit_lsn)
+
+
+async def main():
+    options = WalboxOptions(
+        consumer_name="app",
+        dsn="postgresql://user:password@localhost/db",
+        slot_name="slot",
+        publication_name="walbox_pub",
+    )
+    client = Walbox.build(options)
+    await client.run(handle)
+
+
+asyncio.run(main())
+```
+
+Run it, then insert a row:
+
+```sh
+python handler.py
+# In another terminal:
+INSERT INTO outbox (entity_type, entity_id, event_type, payload)
+VALUES ('user', '42', 'created', '{"name":"Alice"}'::jsonb);
+```
+
+The handler receives the row and saves a durable checkpoint. On restart, it resumes from that checkpoint. No data loss.
+
+See [**Examples**](https://github.com/mochams/walbox/tree/main/examples) for working patterns: publishing to a message broker, writing to a PostgreSQL sink with exactly-once effects, sharded concurrent handling, and metrics.
+
+## Next steps
+
+- **[Quickstart](https://mochams.github.io/walbox/getting-started/quickstart/)** (5 minutes): step-by-step setup
+- **[Getting Started](https://mochams.github.io/walbox/getting-started/introduction/)**: concepts and guarantees
+- **[Production Guide](https://mochams.github.io/walbox/production/architecture/)**: deployment, monitoring, configuration
+
+## Status
+
+walbox is at v1.0.0. It has 100% branch coverage, integration tests against real PostgreSQL, and went through three pre-release cycles (beta.1, beta.2, rc.1) to settle the API.
+
+See [`CHANGELOG.md`](CHANGELOG.md) for what's changed release to release, and the [Upgrading guide](https://mochams.github.io/walbox/migration/) if you're on a pre-1.0.0 version.
+
+## API Stability
+
+As of v1.0.0, the following are stable and won't break within the 1.0.x series:
+
+- `Walbox` (`build`, `build_with_pool`)
+- `Client`
+- `WalboxOptions`
+- `ConnectionPool`
+- `Transaction`
+- `ChangeEvent`, `ChangeKind`
+- `CheckpointHandle`
+- `Metrics`, `MetricsCallback`
+- `WalboxError` and its subclasses
+
+`walbox.abc` and `walbox.checkpoint` expose the underlying protocols and the PostgreSQL checkpoint store, for advanced use like manual `Client` construction or a custom `CheckpointStore`. These are lower-level and may change shape in a minor release.
+
+1.0.x releases can add fields or methods, but won't remove or change the meaning of anything listed above.
+
+**Development**: see [`CONTRIBUTING.md`](CONTRIBUTING.md) for setup and [`LICENSE`](LICENSE) for terms.

walbox-1.0.0/README.md

@@ -0,0 +1,129 @@
+# walbox
+
+[![PyPI](https://img.shields.io/pypi/v/walbox.svg)](https://pypi.org/project/walbox/)
+[![CI](https://github.com/mochams/walbox/actions/workflows/ci.yml/badge.svg)](https://github.com/mochams/walbox/actions/workflows/ci.yml)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Async Python runtime for consuming PostgreSQL logical replication as a stream of committed transactions.
+
+**[📖 Documentation](https://mochams.github.io/walbox/) · [⚡ Quickstart](https://mochams.github.io/walbox/getting-started/quickstart/)**
+
+**Some reasons you might want to use walbox:**
+
+- **You want to react to database changes in real time** without polling tables or adding fragile trigger-based workarounds.
+- **You care about reliable delivery**: walbox checkpoints progress durably so it can resume cleanly after restarts or connection drops.
+- **You’re building around the transactional outbox pattern** and want a consumer that preserves commit ordering and handles recovery sensibly.
+- **You want backpressure built in**, so a slow handler does not turn into unbounded memory growth or silent data loss.
+- **You need a Python async consumer** that plugs directly into PostgreSQL logical replication instead of shoving data through a separate broker.
+- **You want to stream changes from published tables** without writing your own replication client, reconnect logic, or checkpoint tracking.
+- **You want operational visibility**: retries, lag, queue depth, and checkpoint timing are all surfaced so production behavior is easier to reason about.
+
+## Guarantees
+
+- **At-least-once delivery**: a durable local checkpoint ensures committed events are not silently skipped
+- **Transactional consistency**: outbox events are committed atomically with your business data
+- **No polling**: consumes changes directly from PostgreSQL logical replication
+- **Bounded backpressure**: queue limits prevent a slow handler from accumulating unbounded memory
+- **Automatic recovery**: resumes from the last durable checkpoint on restart
+- **Graceful shutdown**: lets in-flight work complete before exiting
+- **Asyncio-native**: built for Python's async runtime
+
+## Install
+
+```sh
+pip install walbox
+```
+
+Psycopg 3 is the only Python dependency. By default it uses your system's `libpq`; if you don't have it installed, use the binary distribution: `pip install walbox psycopg[binary]`.
+
+## Example
+
+PostgreSQL setup (one-time):
+
+```sql
+CREATE TABLE outbox (
+    id BIGSERIAL PRIMARY KEY, entity_type TEXT, entity_id TEXT,
+    event_type TEXT, payload JSONB, created_at TIMESTAMPTZ DEFAULT now()
+);
+CREATE PUBLICATION walbox_pub FOR TABLE outbox;
+```
+
+Handler (`handler.py`):
+
+```python
+import asyncio
+from walbox import (
+    ChangeKind,
+    CheckpointHandle,
+    Transaction,
+    Walbox,
+    WalboxOptions,
+)
+
+
+async def handle(tx: Transaction, checkpoint: CheckpointHandle) -> None:
+    for change in tx.changes:
+        if change.table == "public.outbox" and change.kind == ChangeKind.INSERT:
+            print(f"Event: {change.new}")
+    await checkpoint.save(tx.commit_lsn)
+
+
+async def main():
+    options = WalboxOptions(
+        consumer_name="app",
+        dsn="postgresql://user:password@localhost/db",
+        slot_name="slot",
+        publication_name="walbox_pub",
+    )
+    client = Walbox.build(options)
+    await client.run(handle)
+
+
+asyncio.run(main())
+```
+
+Run it, then insert a row:
+
+```sh
+python handler.py
+# In another terminal:
+INSERT INTO outbox (entity_type, entity_id, event_type, payload)
+VALUES ('user', '42', 'created', '{"name":"Alice"}'::jsonb);
+```
+
+The handler receives the row and saves a durable checkpoint. On restart, it resumes from that checkpoint. No data loss.
+
+See [**Examples**](https://github.com/mochams/walbox/tree/main/examples) for working patterns: publishing to a message broker, writing to a PostgreSQL sink with exactly-once effects, sharded concurrent handling, and metrics.
+
+## Next steps
+
+- **[Quickstart](https://mochams.github.io/walbox/getting-started/quickstart/)** (5 minutes): step-by-step setup
+- **[Getting Started](https://mochams.github.io/walbox/getting-started/introduction/)**: concepts and guarantees
+- **[Production Guide](https://mochams.github.io/walbox/production/architecture/)**: deployment, monitoring, configuration
+
+## Status
+
+walbox is at v1.0.0. It has 100% branch coverage, integration tests against real PostgreSQL, and went through three pre-release cycles (beta.1, beta.2, rc.1) to settle the API.
+
+See [`CHANGELOG.md`](CHANGELOG.md) for what's changed release to release, and the [Upgrading guide](https://mochams.github.io/walbox/migration/) if you're on a pre-1.0.0 version.
+
+## API Stability
+
+As of v1.0.0, the following are stable and won't break within the 1.0.x series:
+
+- `Walbox` (`build`, `build_with_pool`)
+- `Client`
+- `WalboxOptions`
+- `ConnectionPool`
+- `Transaction`
+- `ChangeEvent`, `ChangeKind`
+- `CheckpointHandle`
+- `Metrics`, `MetricsCallback`
+- `WalboxError` and its subclasses
+
+`walbox.abc` and `walbox.checkpoint` expose the underlying protocols and the PostgreSQL checkpoint store, for advanced use like manual `Client` construction or a custom `CheckpointStore`. These are lower-level and may change shape in a minor release.
+
+1.0.x releases can add fields or methods, but won't remove or change the meaning of anything listed above.
+
+**Development**: see [`CONTRIBUTING.md`](CONTRIBUTING.md) for setup and [`LICENSE`](LICENSE) for terms.

walbox-1.0.0/pyproject.toml

@@ -0,0 +1,173 @@
+[build-system]
+requires = ["uv_build>=0.11.0,<0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "walbox"
+version = "1.0.0"
+description = "Async PostgreSQL logical-replication runtime for the transactional outbox pattern"
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "postgresql",
+    "logical-replication",
+    "outbox",
+    "asyncio",
+    "cdc",
+    "change-data-capture",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Typing :: Typed",
+]
+dependencies = ["psycopg>=3.0,<4"]
+
+[[project.authors]]
+name = "Mochama Adriano"
+
+[project.urls]
+Homepage = "https://github.com/mochams/walbox"
+Documentation = "https://mochams.github.io/walbox/"
+Repository = "https://github.com/mochams/walbox"
+Issues = "https://github.com/mochams/walbox/issues"
+Author = "https://github.com/mochams"
+
+[dependency-groups]
+dev = [
+    "cryptography>=50.0.0",
+    "mkdocs==1.6.1",
+    "mkdocs-material==9.7.7",
+    "prek>=0.4.13",
+    "psycopg-pool>=3.3.1",
+    "psycopg[binary]>=3.2",
+    "pylinkvalidator==0.3",
+    "pyrefly>=1.2.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+    "pytest-timeout>=2.4.0",
+    "pytest-xdist>=3.8.0",
+    "ruff>=0.16.1",
+    "testcontainers[postgres]>=4.15",
+]
+
+[tool.uv.build-backend]
+module-name = "walbox"
+module-root = "."
+
+[tool.ruff]
+extend-exclude = [
+    "docs",
+    "pages",
+]
+line-length = 88
+indent-width = 4
+target-version = "py313"
+
+[tool.ruff.lint]
+preview = true
+select = ["ALL"]
+ignore = [
+    "assert",
+    "mutable-class-default",
+    "collapsible-if",
+    "missing-copyright-notice",
+    "missing-return-type-undocumented-public-function",
+    "missing-return-type-private-function",
+    "no-self-use",
+    "unused-method-argument",
+    "undefined-local-with-import-star-usage",
+    "class-as-data-structure",
+]
+exclude = ["tests/*.py"]
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.lint.isort]
+force-single-line = true
+case-sensitive = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.pylint]
+max-args = 7
+
+[tool.ruff.format]
+preview = true
+exclude = [
+    "COM812",
+    "ISC001",
+]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = true
+docstring-code-line-length = 88
+
+[tool.pyrefly]
+min-severity = "warn"
+project-excludes = [
+    "tests",
+    "docs",
+    "examples",
+    "pages",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+addopts = [
+    "--strict-markers",
+    "--cov=walbox",
+    "--cov-fail-under=100",
+    "--cov-report=term-missing",
+    "--durations=10",
+    "--timeout=10",
+    "-n 0",
+]
+testpaths = ["tests"]
+markers = ["postgres: requires a real PostgreSQL instance, started via testcontainers (make test-integration)"]
+log_cli = "false"
+log_cli_level = "ERROR"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+
+[tool.coverage.run]
+branch = true
+disable_warnings = [
+    "include-ignored",
+    "no-data-collected",
+]
+parallel = true
+concurrency = [
+    "multiprocessing",
+    "thread",
+]
+
+[tool.coverage.report]
+exclude_also = [
+    "def __repr__",
+    "def __str__",
+    'if self\.debug',
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    '@(abc\.)?abstractmethod',
+    '^\s*\.\.\.$',
+    "if TYPE_CHECKING:",
+]
+skip_covered = "true"

walbox-1.0.0/pyproject.toml.orig

@@ -0,0 +1,207 @@
+[build-system]
+requires = ["uv_build>=0.11.0,<0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "walbox"
+version = "1.0.0"
+description = "Async PostgreSQL logical-replication runtime for the transactional outbox pattern"
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Mochama Adriano" }]
+keywords = [
+    "postgresql",
+    "logical-replication",
+    "outbox",
+    "asyncio",
+    "cdc",
+    "change-data-capture",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Typing :: Typed",
+]
+dependencies = ["psycopg>=3.0,<4"]
+
+[project.urls]
+Homepage = "https://github.com/mochams/walbox"
+Documentation = "https://mochams.github.io/walbox/"
+Repository = "https://github.com/mochams/walbox"
+Issues = "https://github.com/mochams/walbox/issues"
+Author = "https://github.com/mochams"
+
+
+[dependency-groups]
+dev = [
+    "cryptography>=50.0.0",
+    "mkdocs==1.6.1",
+    "mkdocs-material==9.7.7",
+    "prek>=0.4.13",
+    "psycopg-pool>=3.3.1",
+    "psycopg[binary]>=3.2",
+    "pylinkvalidator==0.3",
+    "pyrefly>=1.2.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+    "pytest-timeout>=2.4.0",
+    "pytest-xdist>=3.8.0",
+    "ruff>=0.16.1",
+    "testcontainers[postgres]>=4.15",
+]
+
+[tool.uv.build-backend]
+module-name = "walbox"
+module-root = "."
+
+
+# ==== Ruff ====
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+extend-exclude = ["docs", "pages"]
+
+# Python line length and indent width
+line-length = 88
+indent-width = 4
+
+# Assume Python 3.13
+target-version = "py313"
+
+[tool.ruff.lint]
+# Enable opt-in preview mode
+preview = true
+
+# Enable rules
+select = ['ALL']
+ignore = [
+    "assert",                                           # Use of assert detected https://docs.astral.sh/ruff/rules/assert/
+    "mutable-class-default",                            # Mutable class attributes should be annotated with `typing.ClassVar`
+    "collapsible-if",                                   # Sometimes it's better to nest
+    "missing-copyright-notice",                         # Copyright
+    "missing-return-type-undocumented-public-function", # Return type annotation
+    "missing-return-type-private-function",             # Return type annotation (private)
+    "no-self-use",                                      # Sometimes it is possible i.e interface methods
+    "unused-method-argument",                           # Sometimes it is possible i.e interface methods
+    "undefined-local-with-import-star-usage",
+    "class-as-data-structure",
+]
+
+# Exclude for tests
+exclude = ["tests/*.py"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Enable opt-in preview mode
+preview = true
+
+# Ignore
+exclude = ["COM812", "ISC001"]
+
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings.
+docstring-code-format = true
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+docstring-code-line-length = 88
+
+[tool.ruff.lint.isort]
+# Forces all from imports to appear on their own line.
+force-single-line = true
+
+# Sort imports in a case-sensitive manner.
+case-sensitive = true
+
+[tool.ruff.lint.pydocstyle]
+# Whether to use Google-style, NumPy-style conventions, or the PEP 257 default.
+convention = "google"
+
+[tool.ruff.lint.pylint]
+# Maximum number of arguments allowed for a function or method definition
+max-args = 7
+
+
+# === Pyrefly ===
+[tool.pyrefly]
+min-severity = "warn"
+project-excludes = ["tests", "docs", "examples", "pages"]
+
+
+# === Pytest ===
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+addopts = [
+    "--strict-markers",
+    "--cov=walbox",
+    "--cov-fail-under=100",
+    "--cov-report=term-missing",
+    "--durations=10",
+    "--timeout=10",
+    "-n 0",
+]
+testpaths = ["tests"]
+markers = [
+    "postgres: requires a real PostgreSQL instance, started via testcontainers (make test-integration)",
+]
+log_cli = "false"
+log_cli_level = "ERROR"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+
+
+# ==== Coverage ====
+[tool.coverage.run]
+branch = true
+disable_warnings = ["include-ignored", "no-data-collected"]
+
+parallel = true
+concurrency = ["multiprocessing", "thread"]
+
+[tool.coverage.report]
+exclude_also = [
+    # Don't complain about missing debug-only code:
+    "def __repr__",
+    "def __str__",
+    "if self\\.debug",
+    # Don't complain if tests don't hit defensive assertion code:
+    "raise AssertionError",
+    "raise NotImplementedError",
+    # Don't complain if non-runnable code isn't run:
+    "if 0:",
+    "if __name__ == .__main__.:",
+    # Don't complain about abstract methods, they aren't run:
+    "@(abc\\.)?abstractmethod",
+    # Exclude protocol methods implementations i.e '...', they aren't run:
+    "^\\s*\\.\\.\\.$",
+    # Exclude TYPE_CHECKING blocks
+    "if TYPE_CHECKING:",
+]
+skip_covered = "true"