beanqueue 1.2.0__tar.gz → 2.0.0rc1__tar.gz

beanqueue-1.2.0/README.md → beanqueue-2.0.0rc1/PKG-INFO

@@ -1,6 +1,26 @@
+Metadata-Version: 2.5
+Name: beanqueue
+Version: 2.0.0rc1
+Summary: BeanQueue or BQ for short, PostgreSQL SKIP LOCK and SQLAlchemy based worker queue library
+Author-email: Fang-Pen Lin <fangpen@launchplatform.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: <4,>=3.11
+Requires-Dist: blinker<2,>=1.8.2
+Requires-Dist: click<9,>=8.1.7
+Requires-Dist: psycopg[binary]<4,>=3.1
+Requires-Dist: pydantic-settings<3,>=2.2.1
+Requires-Dist: rich<14,>=13.7.1
+Requires-Dist: sqlalchemy[asyncio]<3,>=2.0.30
+Requires-Dist: venusian<4,>=3.1.0
+Provides-Extra: metrics
+Requires-Dist: starlette<2,>=0.27; extra == 'metrics'
+Requires-Dist: uvicorn<1,>=0.30.0; extra == 'metrics'
+Description-Content-Type: text/markdown
+
 # BeanQueue [![CircleCI](https://dl.circleci.com/status-badge/img/gh/LaunchPlatform/bq/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/LaunchPlatform/bq/tree/master)
 
-BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
+BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/) 2.0 asyncio, [psycopg3](https://www.psycopg.org/psycopg3/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
 
 **Notice**: Still in its early stage, we built this for [BeanHub](https://beanhub.io)'s internal usage. May change rapidly. Use at your own risk for now.
 
@@ -14,6 +34,7 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 - **Retry**: Built-in and customizable retry policies
 - **Schedule**: Schedule tasks to run later
 - **Worker heartbeat and auto-reschedule**: Each worker keeps updating heartbeat, if one is found dead, the others will reschedule the tasks
+- **Custom health checks**: Optional HTTP `/healthz` endpoint with pluggable checks via Blinker signals
 - **Customizable**: Custom Task, Worker and Event models. Use it as a library and build your own work queue
 
 ## Install
@@ -22,12 +43,45 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 pip install beanqueue
 ```
 
+To enable the optional metrics HTTP server (currently `/healthz` only), install with the `metrics` extra:
+
+```bash
+pip install "beanqueue[metrics]"
+```
+
+## Testing
+
+Unit and in-process acceptance tests:
+
+```bash
+uv run python -m pytest tests
+```
+
+End-to-end tests start PostgreSQL and three worker containers with Docker Compose, enqueue real tasks, apply load, kill a worker, and check graceful shutdown cleanup:
+
+```bash
+uv run python -m pytest tests/e2e -svvvv
+```
+
+## Upgrading to 2.0
+
+BeanQueue 2.0 is asyncio-first (SQLAlchemy `AsyncSession` + psycopg3) and includes breaking changes:
+
+- **Workers use asyncio SQLAlchemy.** `BeanQueue.make_session()` returns an `AsyncSession`, `engine` is an `AsyncEngine`, and `process_tasks()` is `async`. Run it with `asyncio.run(app.process_tasks(...))` or `await` it from your own loop.
+- **Database URLs use the psycopg3 driver.** Prefer `postgresql+psycopg://...`. Bare `postgresql://...` URLs are normalized to `postgresql+psycopg://...`.
+- **`MAX_WORKER_THREADS` is now `MAX_CONCURRENT_TASKS`.** `BQ_MAX_WORKER_THREADS` and the old keyword still work as a deprecated alias.
+- **Processors may be `async def` or `def`.** Async processors receive `db: AsyncSession`. Sync processors that take `db` still receive a sync `Session` via `AsyncSession.run_sync()`.
+- **`METRICS_HTTP_SERVER_ENABLED` defaults to `False`** (it was `True` in 1.x). Set `BQ_METRICS_HTTP_SERVER_ENABLED=true` to turn the server back on.
+- **The metrics server requires optional dependencies.** Install `beanqueue[metrics]` (`starlette` and `uvicorn`). Without them, enabling the server raises an error at startup.
+- **Custom health checks use the `healthz_check` event** (`bq.events.healthz_check`) instead of a `healthz_check` argument on `bq.BeanQueue`. Receivers that query the database should use `AsyncSession` (`await session.execute(...)`).
+
 ## Usage
 
 You can define a basic task processor like this
 
 ```python
-from sqlalchemy.orm import Session
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 import bq
 from .. import models
@@ -35,15 +89,20 @@ from .. import image_utils
 
 app = bq.BeanQueue()
 
+
 @app.processor(channel="images")
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
-    image = db.query(models.Image).filter(models.Image.task == task).one()
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
+    image = (
+        await db.execute(select(models.Image).where(models.Image.task == task))
+    ).scalar_one()
     image_utils.resize(image, size=(width, height))
     db.add(image)
     # by default the `processor` decorator has `auto_complete` flag turns on,
     # so it will commit the db changes for us automatically
 ```
 
+Synchronous processors are still supported. If the function takes a `db` argument, BeanQueue injects the sync `Session` behind the `AsyncSession`. Processors that do not use the database can stay as plain `def` functions and are run in a worker thread so they do not block the event loop.
+
 The `db` and `task` keyword arguments are optional.
 If you don't need to access the task object, you can simply define the function without these two parameters.
 We also provide an optional `savepoint` argument in case if you want to rollback database changes you made.
@@ -137,13 +196,14 @@ To automatically retry a task after failure, you can specify a retry policy to t
 ```python
 import datetime
 import bq
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 
 app = bq.BeanQueue()
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
 
+
 @app.processor(channel="images", retry_policy=delay_retry)
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # resize image here ...
     pass
 ```
@@ -163,8 +223,9 @@ To cap how many attempts are allowed, you can also use `LimitAttempt` like this:
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
 capped_delay_retry = bq.LimitAttempt(3, delay_retry)
 
+
 @app.processor(channel="images", retry_policy=capped_delay_retry)
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # Resize image here ...
     pass
 ```
@@ -177,7 +238,7 @@ You can also retry only for specific exception classes with the `retry_exception
     retry_policy=delay_retry,
     retry_exceptions=ValueError,
 )
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # resize image here ...
     pass
 ```
@@ -213,9 +274,96 @@ bq -a my_pkgs.bq.app process images
 Or if you prefer to define your own process command, you can also call `process_tasks` of the `BeanQueue` object directly like this:
 
 ```python
-app.process_tasks(channels=("images",))
+import asyncio
+
+asyncio.run(app.process_tasks(channels=("images",)))
+```
+
+### Health check and metrics HTTP server
+
+When enabled, each worker starts a small HTTP server (Starlette + Uvicorn) for operational endpoints.
+Today this only exposes `GET /healthz`, which returns `{"status": "ok"}` by default.
+
+Enable it with the `metrics` extra installed and configuration:
+
+```bash
+pip install "beanqueue[metrics]"
+BQ_METRICS_HTTP_SERVER_ENABLED=true bq process images
+```
+
+Relevant settings (see [bq/config.py](bq/config.py)):
+
+| Setting | Env var | Default |
+| --- | --- | --- |
+| `METRICS_HTTP_SERVER_ENABLED` | `BQ_METRICS_HTTP_SERVER_ENABLED` | `False` |
+| `METRICS_HTTP_SERVER_INTERFACE` | `BQ_METRICS_HTTP_SERVER_INTERFACE` | `""` (all interfaces) |
+| `METRICS_HTTP_SERVER_PORT` | `BQ_METRICS_HTTP_SERVER_PORT` | `8000` |
+| `METRICS_HTTP_SERVER_LOG_LEVEL` | `BQ_METRICS_HTTP_SERVER_LOG_LEVEL` | `30` (`WARNING`) |
+
+Access requests are logged at INFO via `uvicorn.access` (visible even when `METRICS_HTTP_SERVER_LOG_LEVEL` is `WARNING`).
+BeanQueue also uses a `metrics_server` logger for its own messages.
+Override the entire logging setup by passing a [logging.config](https://docs.python.org/3/library/logging.config.html#logging-config-dictschema) dict via `METRICS_HTTP_SERVER_LOG_CONFIG` (or `BQ_METRICS_HTTP_SERVER_LOG_CONFIG` as JSON):
+
+```python
+import bq
+
+config = bq.Config(
+    METRICS_HTTP_SERVER_ENABLED=True,
+    METRICS_HTTP_SERVER_LOG_CONFIG={
+        "version": 1,
+        "disable_existing_loggers": False,
+        "handlers": {
+            "default": {
+                "class": "logging.StreamHandler",
+                "formatter": "default",
+            }
+        },
+        "formatters": {
+            "default": {
+                "format": "%(asctime)s %(name)s %(levelname)s %(message)s",
+            }
+        },
+        "loggers": {
+            "metrics_server": {"handlers": ["default"], "level": "INFO"},
+            "uvicorn.access": {"handlers": ["default"], "level": "INFO"},
+        },
+    },
+)
+app = bq.BeanQueue(config=config)
+```
+
+#### Custom health checks
+
+Register additional checks by connecting receivers to `bq.events.healthz_check`.
+If no receivers are connected, `/healthz` returns OK without touching the database.
+
+With receivers connected, BeanQueue loads the current worker and passes a database `session` to each check.
+Receivers may be synchronous or asynchronous; both can be mixed on the same signal.
+
+```python
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+import bq
+from bq import events
+
+app = bq.BeanQueue()
+
+
+@events.healthz_check.connect
+async def check_database(sender: bq.BeanQueue, worker, session: AsyncSession):
+    await session.execute(text("SELECT 1"))
+
+
+@events.healthz_check.connect
+async def check_external_service(sender: bq.BeanQueue, worker, session: AsyncSession):
+    # async HTTP call, etc.
+    ...
 ```
 
+Receiver signature must accept the keyword arguments you need, for example `(sender, worker, session)`, or use `(sender, **kwargs)`.
+If a check raises an exception, `/healthz` responds with HTTP 500 and a JSON body containing the error message.
+
 ### Define your own tables
 
 BeanQueue is designed to be as customizable as much as possible.
@@ -261,6 +409,7 @@ class Task(bq.TaskModelMixin, Base):
         "Worker", back_populates="tasks", uselist=False
     )
 
+
 listen_events(Task)
 ```
 
@@ -293,6 +442,7 @@ With the model class ready, you only need to change the `TASK_MODEL`, `WORKER_MO
 
 ```python
 import bq
+
 config = bq.Config(
     TASK_MODEL="my_pkgs.models.Task",
     WORKER_MODEL="my_pkgs.models.Worker",

beanqueue-1.2.0/PKG-INFO → beanqueue-2.0.0rc1/README.md

@@ -1,22 +1,6 @@
-Metadata-Version: 2.4
-Name: beanqueue
-Version: 1.2.0
-Summary: BeanQueue or BQ for short, PostgreSQL SKIP LOCK and SQLAlchemy based worker queue library
-Author-email: Fang-Pen Lin <fangpen@launchplatform.com>
-License-Expression: MIT
-License-File: LICENSE
-Requires-Python: <4,>=3.11
-Requires-Dist: blinker<2,>=1.8.2
-Requires-Dist: click<9,>=8.1.7
-Requires-Dist: pydantic-settings<3,>=2.2.1
-Requires-Dist: rich<14,>=13.7.1
-Requires-Dist: sqlalchemy<3,>=2.0.30
-Requires-Dist: venusian<4,>=3.1.0
-Description-Content-Type: text/markdown
-
 # BeanQueue [![CircleCI](https://dl.circleci.com/status-badge/img/gh/LaunchPlatform/bq/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/LaunchPlatform/bq/tree/master)
 
-BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
+BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https://www.sqlalchemy.org/) 2.0 asyncio, [psycopg3](https://www.psycopg.org/psycopg3/), PostgreSQL [SKIP LOCKED queries](https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/) and [NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html) / [LISTEN](https://www.postgresql.org/docs/current/sql-listen.html) statements.
 
 **Notice**: Still in its early stage, we built this for [BeanHub](https://beanhub.io)'s internal usage. May change rapidly. Use at your own risk for now.
 
@@ -30,6 +14,7 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 - **Retry**: Built-in and customizable retry policies
 - **Schedule**: Schedule tasks to run later
 - **Worker heartbeat and auto-reschedule**: Each worker keeps updating heartbeat, if one is found dead, the others will reschedule the tasks
+- **Custom health checks**: Optional HTTP `/healthz` endpoint with pluggable checks via Blinker signals
 - **Customizable**: Custom Task, Worker and Event models. Use it as a library and build your own work queue
 
 ## Install
@@ -38,12 +23,45 @@ BeanQueue, a lightweight Python task queue framework based on [SQLAlchemy](https
 pip install beanqueue
 ```
 
+To enable the optional metrics HTTP server (currently `/healthz` only), install with the `metrics` extra:
+
+```bash
+pip install "beanqueue[metrics]"
+```
+
+## Testing
+
+Unit and in-process acceptance tests:
+
+```bash
+uv run python -m pytest tests
+```
+
+End-to-end tests start PostgreSQL and three worker containers with Docker Compose, enqueue real tasks, apply load, kill a worker, and check graceful shutdown cleanup:
+
+```bash
+uv run python -m pytest tests/e2e -svvvv
+```
+
+## Upgrading to 2.0
+
+BeanQueue 2.0 is asyncio-first (SQLAlchemy `AsyncSession` + psycopg3) and includes breaking changes:
+
+- **Workers use asyncio SQLAlchemy.** `BeanQueue.make_session()` returns an `AsyncSession`, `engine` is an `AsyncEngine`, and `process_tasks()` is `async`. Run it with `asyncio.run(app.process_tasks(...))` or `await` it from your own loop.
+- **Database URLs use the psycopg3 driver.** Prefer `postgresql+psycopg://...`. Bare `postgresql://...` URLs are normalized to `postgresql+psycopg://...`.
+- **`MAX_WORKER_THREADS` is now `MAX_CONCURRENT_TASKS`.** `BQ_MAX_WORKER_THREADS` and the old keyword still work as a deprecated alias.
+- **Processors may be `async def` or `def`.** Async processors receive `db: AsyncSession`. Sync processors that take `db` still receive a sync `Session` via `AsyncSession.run_sync()`.
+- **`METRICS_HTTP_SERVER_ENABLED` defaults to `False`** (it was `True` in 1.x). Set `BQ_METRICS_HTTP_SERVER_ENABLED=true` to turn the server back on.
+- **The metrics server requires optional dependencies.** Install `beanqueue[metrics]` (`starlette` and `uvicorn`). Without them, enabling the server raises an error at startup.
+- **Custom health checks use the `healthz_check` event** (`bq.events.healthz_check`) instead of a `healthz_check` argument on `bq.BeanQueue`. Receivers that query the database should use `AsyncSession` (`await session.execute(...)`).
+
 ## Usage
 
 You can define a basic task processor like this
 
 ```python
-from sqlalchemy.orm import Session
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 import bq
 from .. import models
@@ -51,15 +69,20 @@ from .. import image_utils
 
 app = bq.BeanQueue()
 
+
 @app.processor(channel="images")
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
-    image = db.query(models.Image).filter(models.Image.task == task).one()
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
+    image = (
+        await db.execute(select(models.Image).where(models.Image.task == task))
+    ).scalar_one()
     image_utils.resize(image, size=(width, height))
     db.add(image)
     # by default the `processor` decorator has `auto_complete` flag turns on,
     # so it will commit the db changes for us automatically
 ```
 
+Synchronous processors are still supported. If the function takes a `db` argument, BeanQueue injects the sync `Session` behind the `AsyncSession`. Processors that do not use the database can stay as plain `def` functions and are run in a worker thread so they do not block the event loop.
+
 The `db` and `task` keyword arguments are optional.
 If you don't need to access the task object, you can simply define the function without these two parameters.
 We also provide an optional `savepoint` argument in case if you want to rollback database changes you made.
@@ -153,13 +176,14 @@ To automatically retry a task after failure, you can specify a retry policy to t
 ```python
 import datetime
 import bq
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 
 app = bq.BeanQueue()
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
 
+
 @app.processor(channel="images", retry_policy=delay_retry)
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # resize image here ...
     pass
 ```
@@ -179,8 +203,9 @@ To cap how many attempts are allowed, you can also use `LimitAttempt` like this:
 delay_retry = bq.DelayRetry(delay=datetime.timedelta(seconds=120))
 capped_delay_retry = bq.LimitAttempt(3, delay_retry)
 
+
 @app.processor(channel="images", retry_policy=capped_delay_retry)
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # Resize image here ...
     pass
 ```
@@ -193,7 +218,7 @@ You can also retry only for specific exception classes with the `retry_exception
     retry_policy=delay_retry,
     retry_exceptions=ValueError,
 )
-def resize_image(db: Session, task: bq.Task, width: int, height: int):
+async def resize_image(db: AsyncSession, task: bq.Task, width: int, height: int):
     # resize image here ...
     pass
 ```
@@ -229,9 +254,96 @@ bq -a my_pkgs.bq.app process images
 Or if you prefer to define your own process command, you can also call `process_tasks` of the `BeanQueue` object directly like this:
 
 ```python
-app.process_tasks(channels=("images",))
+import asyncio
+
+asyncio.run(app.process_tasks(channels=("images",)))
+```
+
+### Health check and metrics HTTP server
+
+When enabled, each worker starts a small HTTP server (Starlette + Uvicorn) for operational endpoints.
+Today this only exposes `GET /healthz`, which returns `{"status": "ok"}` by default.
+
+Enable it with the `metrics` extra installed and configuration:
+
+```bash
+pip install "beanqueue[metrics]"
+BQ_METRICS_HTTP_SERVER_ENABLED=true bq process images
+```
+
+Relevant settings (see [bq/config.py](bq/config.py)):
+
+| Setting | Env var | Default |
+| --- | --- | --- |
+| `METRICS_HTTP_SERVER_ENABLED` | `BQ_METRICS_HTTP_SERVER_ENABLED` | `False` |
+| `METRICS_HTTP_SERVER_INTERFACE` | `BQ_METRICS_HTTP_SERVER_INTERFACE` | `""` (all interfaces) |
+| `METRICS_HTTP_SERVER_PORT` | `BQ_METRICS_HTTP_SERVER_PORT` | `8000` |
+| `METRICS_HTTP_SERVER_LOG_LEVEL` | `BQ_METRICS_HTTP_SERVER_LOG_LEVEL` | `30` (`WARNING`) |
+
+Access requests are logged at INFO via `uvicorn.access` (visible even when `METRICS_HTTP_SERVER_LOG_LEVEL` is `WARNING`).
+BeanQueue also uses a `metrics_server` logger for its own messages.
+Override the entire logging setup by passing a [logging.config](https://docs.python.org/3/library/logging.config.html#logging-config-dictschema) dict via `METRICS_HTTP_SERVER_LOG_CONFIG` (or `BQ_METRICS_HTTP_SERVER_LOG_CONFIG` as JSON):
+
+```python
+import bq
+
+config = bq.Config(
+    METRICS_HTTP_SERVER_ENABLED=True,
+    METRICS_HTTP_SERVER_LOG_CONFIG={
+        "version": 1,
+        "disable_existing_loggers": False,
+        "handlers": {
+            "default": {
+                "class": "logging.StreamHandler",
+                "formatter": "default",
+            }
+        },
+        "formatters": {
+            "default": {
+                "format": "%(asctime)s %(name)s %(levelname)s %(message)s",
+            }
+        },
+        "loggers": {
+            "metrics_server": {"handlers": ["default"], "level": "INFO"},
+            "uvicorn.access": {"handlers": ["default"], "level": "INFO"},
+        },
+    },
+)
+app = bq.BeanQueue(config=config)
+```
+
+#### Custom health checks
+
+Register additional checks by connecting receivers to `bq.events.healthz_check`.
+If no receivers are connected, `/healthz` returns OK without touching the database.
+
+With receivers connected, BeanQueue loads the current worker and passes a database `session` to each check.
+Receivers may be synchronous or asynchronous; both can be mixed on the same signal.
+
+```python
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+import bq
+from bq import events
+
+app = bq.BeanQueue()
+
+
+@events.healthz_check.connect
+async def check_database(sender: bq.BeanQueue, worker, session: AsyncSession):
+    await session.execute(text("SELECT 1"))
+
+
+@events.healthz_check.connect
+async def check_external_service(sender: bq.BeanQueue, worker, session: AsyncSession):
+    # async HTTP call, etc.
+    ...
 ```
 
+Receiver signature must accept the keyword arguments you need, for example `(sender, worker, session)`, or use `(sender, **kwargs)`.
+If a check raises an exception, `/healthz` responds with HTTP 500 and a JSON body containing the error message.
+
 ### Define your own tables
 
 BeanQueue is designed to be as customizable as much as possible.
@@ -277,6 +389,7 @@ class Task(bq.TaskModelMixin, Base):
         "Worker", back_populates="tasks", uselist=False
     )
 
+
 listen_events(Task)
 ```
 
@@ -309,6 +422,7 @@ With the model class ready, you only need to change the `TASK_MODEL`, `WORKER_MO
 
 ```python
 import bq
+
 config = bq.Config(
     TASK_MODEL="my_pkgs.models.Task",
     WORKER_MODEL="my_pkgs.models.Worker",