deegzlibs-command-bus 2.2.0__tar.gz → 2.3.0__tar.gz

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deegzlibs-command-bus
-Version: 2.2.0
+Version: 2.3.0
 Summary: A small command bus with pluggable queue adapters and response stores (e.g. SQS, RabbitMQ, Redis, etc.)
 Home-page: https://github.com/deegzlibs/deegzlibs
 Author: Diego Alejos
@@ -44,7 +44,7 @@ Dynamic: requires-python
 
 # DeegzLibs CommandBus (Python)
 
-A small command and event bus with pluggable queue adapters. Define messages as Pydantic models, register handlers, and run commands (one worker) or publish events (fan-out) in-process or via a queue (e.g. AWS SQS, SNS, RabbitMQ, Redis).
+A small command and event bus with pluggable queue adapters. Register handlers, send commands or publish events, and process them in-process or through a queue (SQS, SNS, RabbitMQ, Redis, and more).
 
 ## Installation
 
@@ -54,72 +54,97 @@ pip install deegzlibs-command-bus
 
 Optional extras: **`[sqs]`**, **`[sns]`**, **`[boto3]`**, **`[redis]`**, **`[rabbitmq]`**. See [Installation](docs/installation.md).
 
-## Quick start
+## Quick start — commands (WorkerApp)
 
-### Commands
-
-One message is handled by **one worker** (competing consumers):
+**WorkerApp** wraps your handlers and a **queue adapter**. The adapter is the queue itself — `execute()` writes to it, `work()` reads from it. Producer and worker must use the **same adapter** (same backend and queue name):
 
 ```python
-from command_bus import CommandBus, Router, CommandMessage, Handler
+import asyncio
+from command_bus import WorkerApp
 from command_bus.adapters import InMemoryQueueAdapter
 
-router = Router()
-adapter = InMemoryQueueAdapter(queue_name="commands")
-bus = CommandBus(queue_adapter=adapter, command_router=router)
+# Where commands wait between send and process.
+# Swap for SqsQueueAdapter, RedisQueueAdapter, etc. in production.
+queue = InMemoryQueueAdapter(queue_name="orders")
+
+app = WorkerApp(queue_adapter=queue)
 
-@router.command()
+@app.command()
 def on_order_created(order_id: str, amount_cents: int):
     print(f"Order {order_id}: {amount_cents} cents")
 
-# Fire-and-forget
-await bus.execute(on_order_created(order_id="ord-1", amount_cents=1999), wait=False)
+async def main():
+    # Producer: enqueue via the adapter
+    await app.execute(on_order_created(order_id="ord-1", amount_cents=1999), wait=False)
+    # Worker: dequeue via the same adapter
+    await app.work()
 
-# Worker: poll and dispatch
-await bus.work()
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+In production, split this into two modules that share the same queue setup — see [Client and worker](docs/client-and-worker.md).
+
+Run the worker as a separate process (like `uvicorn` for web apps):
+
+```bash
+command-bus-worker myapp.worker:app --workers 4
 ```
 
-### Events
+The CLI imports your module and runs `app.work()` in a loop — it does **not** call `main()`. Your worker module defines `app` (with its adapter and handlers); the client module sends commands using the same queue configuration.
+
+- **`--workers`** — how many worker processes share the queue
+- **`--concurrency`** — how many messages each process handles at once
 
-One publish reaches **every subscriber** (fan-out):
+If you have the repo locally, try the in-memory demo:
+
+```bash
+PYTHONPATH=src python examples/worker_app_demo.py
+```
+
+More on WorkerApp (response stores, production queues, concurrency): [WorkerApp docs](docs/worker-app.md).
+
+Need the lower-level API (`CommandBus`, `Router`, message classes)? See the [full quick start](docs/quickstart.md).
+
+## Quick start — events
+
+Each event is delivered to **every subscriber**:
 
 ```python
 from command_bus import EventBus, Router
 from command_bus.adapters import InMemoryPubSubAdapter
 
 router = Router()
-adapter = InMemoryPubSubAdapter(queue_name="order-events")
-bus = EventBus(queue_adapter=adapter, command_router=router)
+bus = EventBus(
+    queue_adapter=InMemoryPubSubAdapter(queue_name="order-events"),
+    command_router=router,
+)
 
 @router.event()
 def on_order_created(order_id: str, amount_cents: int):
     print(f"Order {order_id}: {amount_cents} cents")
 
-# Producer (no local handler required)
 await bus.publish(on_order_created(order_id="ord-1", amount_cents=1999))
-
-# Each worker with its own adapter on the same topic receives the event
 await bus.work()
 ```
 
-To run workers as **separate OS processes** (useful when handlers do a lot of CPU work), use the built-in CLI, e.g. **`command-bus-worker myapp.worker:bus --workers 4`** (omit **`:bus`** if your bus lives on attribute **`bus`**). For several queues in one supervised tree, point at a **`BusGroup`**, e.g. **`myapp.worker:bus_group`** (see [Worker CLI](docs/cli.md)).
-
-For full examples (messages, handlers, SQS/Redis/SNS, execute-and-wait), see the [documentation](docs/index.md).
+See [Pub/sub events](docs/pubsub-events.md) for fan-out adapters and multi-worker setups.
 
 ## Documentation
 
 | Topic | Description |
 |-------|-------------|
+| [Quick start](docs/quickstart.md) | WorkerApp plus step-by-step wiring. |
+| [WorkerApp](docs/worker-app.md) | Handlers, concurrency, in-memory and production setup. |
+| [Worker CLI](docs/cli.md) | `command-bus-worker module[:attr]`. |
 | [Installation](docs/installation.md) | Package and extras. |
-| [Quick start](docs/quickstart.md) | Messages, handlers, register, execute, publish. |
-| [Handler decorator](docs/handler-decorator.md) | `@router.command()` and message factory. |
-| [Message formats and parsers](docs/message-formats-and-parsers.md) | Repr, JSON, Base64, custom parser. |
-| [Client and worker](docs/client-and-worker.md) | Shared module, producer, consumer. |
-| [Worker CLI](docs/cli.md) | `command-bus-worker module[:attr]` — `CommandBus`, `EventBus`, or `BusGroup`. |
+| [Handler decorator](docs/handler-decorator.md) | `@app.command()` / `@router.command()`. |
+| [Client and worker](docs/client-and-worker.md) | Split producer and consumer in production. |
 | [Queue adapters](docs/queue-adapters.md) | In-memory, SQS, RabbitMQ, Redis. |
-| [Pub/sub events](docs/pubsub-events.md) | EventBus, fan-out adapters, `@router.event()`. |
-| [Execute and wait](docs/execute-and-wait.md) | Response store, request/response. |
-| [API reference](docs/api-reference.md) | Types and methods overview. |
+| [Execute and wait](docs/execute-and-wait.md) | Send a command and get the result back. |
+| [Pub/sub events](docs/pubsub-events.md) | EventBus and fan-out. |
+| [Message formats and parsers](docs/message-formats-and-parsers.md) | Repr, JSON, Base64. |
+| [API reference](docs/api-reference.md) | Types and methods. |
 
 ## License
 

deegzlibs_command_bus-2.3.0/README.md

@@ -0,0 +1,107 @@
+# DeegzLibs CommandBus (Python)
+
+A small command and event bus with pluggable queue adapters. Register handlers, send commands or publish events, and process them in-process or through a queue (SQS, SNS, RabbitMQ, Redis, and more).
+
+## Installation
+
+```bash
+pip install deegzlibs-command-bus
+```
+
+Optional extras: **`[sqs]`**, **`[sns]`**, **`[boto3]`**, **`[redis]`**, **`[rabbitmq]`**. See [Installation](docs/installation.md).
+
+## Quick start — commands (WorkerApp)
+
+**WorkerApp** wraps your handlers and a **queue adapter**. The adapter is the queue itself — `execute()` writes to it, `work()` reads from it. Producer and worker must use the **same adapter** (same backend and queue name):
+
+```python
+import asyncio
+from command_bus import WorkerApp
+from command_bus.adapters import InMemoryQueueAdapter
+
+# Where commands wait between send and process.
+# Swap for SqsQueueAdapter, RedisQueueAdapter, etc. in production.
+queue = InMemoryQueueAdapter(queue_name="orders")
+
+app = WorkerApp(queue_adapter=queue)
+
+@app.command()
+def on_order_created(order_id: str, amount_cents: int):
+    print(f"Order {order_id}: {amount_cents} cents")
+
+async def main():
+    # Producer: enqueue via the adapter
+    await app.execute(on_order_created(order_id="ord-1", amount_cents=1999), wait=False)
+    # Worker: dequeue via the same adapter
+    await app.work()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+In production, split this into two modules that share the same queue setup — see [Client and worker](docs/client-and-worker.md).
+
+Run the worker as a separate process (like `uvicorn` for web apps):
+
+```bash
+command-bus-worker myapp.worker:app --workers 4
+```
+
+The CLI imports your module and runs `app.work()` in a loop — it does **not** call `main()`. Your worker module defines `app` (with its adapter and handlers); the client module sends commands using the same queue configuration.
+
+- **`--workers`** — how many worker processes share the queue
+- **`--concurrency`** — how many messages each process handles at once
+
+If you have the repo locally, try the in-memory demo:
+
+```bash
+PYTHONPATH=src python examples/worker_app_demo.py
+```
+
+More on WorkerApp (response stores, production queues, concurrency): [WorkerApp docs](docs/worker-app.md).
+
+Need the lower-level API (`CommandBus`, `Router`, message classes)? See the [full quick start](docs/quickstart.md).
+
+## Quick start — events
+
+Each event is delivered to **every subscriber**:
+
+```python
+from command_bus import EventBus, Router
+from command_bus.adapters import InMemoryPubSubAdapter
+
+router = Router()
+bus = EventBus(
+    queue_adapter=InMemoryPubSubAdapter(queue_name="order-events"),
+    command_router=router,
+)
+
+@router.event()
+def on_order_created(order_id: str, amount_cents: int):
+    print(f"Order {order_id}: {amount_cents} cents")
+
+await bus.publish(on_order_created(order_id="ord-1", amount_cents=1999))
+await bus.work()
+```
+
+See [Pub/sub events](docs/pubsub-events.md) for fan-out adapters and multi-worker setups.
+
+## Documentation
+
+| Topic | Description |
+|-------|-------------|
+| [Quick start](docs/quickstart.md) | WorkerApp plus step-by-step wiring. |
+| [WorkerApp](docs/worker-app.md) | Handlers, concurrency, in-memory and production setup. |
+| [Worker CLI](docs/cli.md) | `command-bus-worker module[:attr]`. |
+| [Installation](docs/installation.md) | Package and extras. |
+| [Handler decorator](docs/handler-decorator.md) | `@app.command()` / `@router.command()`. |
+| [Client and worker](docs/client-and-worker.md) | Split producer and consumer in production. |
+| [Queue adapters](docs/queue-adapters.md) | In-memory, SQS, RabbitMQ, Redis. |
+| [Execute and wait](docs/execute-and-wait.md) | Send a command and get the result back. |
+| [Pub/sub events](docs/pubsub-events.md) | EventBus and fan-out. |
+| [Message formats and parsers](docs/message-formats-and-parsers.md) | Repr, JSON, Base64. |
+| [API reference](docs/api-reference.md) | Types and methods. |
+
+## License
+
+MIT

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.poetry]
 name = "deegzlibs-command-bus"
-version = "2.2.0"
+version = "2.3.0"
 description = "A small command bus with pluggable queue adapters (e.g. AWS SQS)"
 readme = "README.md"
 authors = ["Diego Alejos <lego.admin@gmail.com>"]
@@ -33,7 +33,7 @@ redis = ["redis"]
 
 [project]
 name = "deegzlibs-command-bus"
-version = "2.2.0"
+version = "2.3.0"
 description = "A small command bus with pluggable queue adapters and response stores (e.g. SQS, RabbitMQ, Redis, etc.)"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -80,7 +80,7 @@ where = ["src"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "2.2.0"
+version = "2.3.0"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="deegzlibs-command-bus",
-    version="2.2.0",
+    version="2.3.0",
     author="Diego Alejos",
     author_email="lego.admin@gmail.com",
     description="A small command bus with pluggable queue adapters (e.g. AWS SQS)",

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/src/command_bus/__init__.py

@@ -40,6 +40,7 @@ from .registry import (
     RouterEntry,
     get_qual_name,
 )
+from .worker_app import WorkerApp
 
 __all__ = [
     "Base64MessageCodec",
@@ -74,6 +75,7 @@ __all__ = [
     "RouterInterface",
     "TransmissibleBaseModel",
     "WorkerConfig",
+    "WorkerApp",
     "configure_json_parser",
     "resolve_bus_attr_on_module",
     "get_qual_name",

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/src/command_bus/bus.py

@@ -151,9 +151,17 @@ class CommandBus(CommandBusInterface):
                 ttl_seconds=self.response_ttl_seconds,
             )
 
-    async def work(self) -> None:
-        """Poll the queue and dispatch each message to its handlers."""
-        messages = self.queue_adapter.get_messages()
-        for message in messages:
-            await self.dispatch(message.body)
-            self.queue_adapter.dequeue(message)
+    async def work(self, *, concurrency: int = 1) -> int:
+        """Poll the queue and dispatch messages to handlers (up to ``concurrency`` in parallel)."""
+        messages = self.queue_adapter.get_messages(max_messages=max(1, concurrency))
+        if not messages:
+            return 0
+
+        async def _handle(message: Any) -> None:
+            try:
+                await self.dispatch(message.body)
+            finally:
+                self.queue_adapter.dequeue(message)
+
+        await asyncio.gather(*(_handle(m) for m in messages))
+        return len(messages)

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/src/command_bus/cli.py

@@ -10,16 +10,19 @@ import multiprocessing
 import signal
 import sys
 import time
-from typing import Any, List, Optional, Sequence, Tuple
+from typing import Any, List, Optional, Sequence, Tuple, Union
 
+from .adapters.queue.in_memory import InMemoryQueueAdapter
 from .bus import CommandBus
 from .command_bus_group import BusGroup, CommandBusGroup, resolve_bus_attr_on_module
 from .event_bus import EventBus
+from .worker_app import WorkerApp
 
 logger = logging.getLogger(__name__)
 
 _DEFAULT_BUS_ATTR = "bus"
 _BUS_TYPES = (CommandBus, EventBus)
+_WORKER_TARGET_TYPES = (CommandBus, EventBus, WorkerApp)
 
 
 def _parse_target(spec: str) -> Tuple[str, str]:
@@ -80,12 +83,28 @@ def _get_multiprocessing_context() -> multiprocessing.context.BaseContext:
     return multiprocessing.get_context("fork")
 
 
+def _queue_name_for_target(target: Union[CommandBus, EventBus, WorkerApp], attr: str) -> str:
+    if isinstance(target, WorkerApp):
+        return getattr(target.queue_adapter, "queue_name", attr)
+    return getattr(target.queue_adapter, "queue_name", attr)
+
+
+async def _do_work(
+    target: Union[CommandBus, EventBus, WorkerApp],
+    concurrency: int,
+) -> int:
+    if isinstance(target, WorkerApp):
+        return await target.work(concurrency=concurrency)
+    return await target.work(concurrency=concurrency)
+
+
 def _process_worker_main(
     module_name: str,
     bus_attr: str,
     worker_num: int,
     poll_interval: float,
     log_level: int,
+    concurrency: int,
 ) -> None:
     """Entry point for each worker process (import module, run work loop)."""
     # Foreground process group delivers SIGINT to all workers; parent coordinates shutdown.
@@ -117,18 +136,27 @@ def _process_worker_main(
         wlog.error("Failed to import %r: %s", module_name, e)
         sys.exit(1)
 
-    bus = getattr(mod, bus_attr, None)
-    if not isinstance(bus, _BUS_TYPES):
-        wlog.error("Attribute %r is not a CommandBus or EventBus", bus_attr)
+    target = getattr(mod, bus_attr, None)
+    if not isinstance(target, _WORKER_TARGET_TYPES):
+        wlog.error(
+            "Attribute %r is not a CommandBus, EventBus, or WorkerApp",
+            bus_attr,
+        )
         sys.exit(1)
 
     name = f"{bus_attr}:{worker_num}"
-    wlog.info("Worker started for bus %r (queue_name=%s)", bus_attr, getattr(bus.queue_adapter, "queue_name", "?"))
+    qn = _queue_name_for_target(target, bus_attr)
+    wlog.info(
+        "Worker started for %r (queue_name=%s, concurrency=%d)",
+        bus_attr,
+        qn,
+        concurrency,
+    )
 
     async def _loop() -> None:
         while not stop:
             try:
-                await bus.work()
+                await _do_work(target, concurrency)
             except asyncio.CancelledError:
                 raise
             except Exception:
@@ -216,6 +244,7 @@ def _run_worker_processes(
     jobs: List[Tuple[str, int]],
     poll_interval: float,
     log_level: int,
+    concurrency: int,
 ) -> None:
     ctx = _get_multiprocessing_context()
     method = ctx.get_start_method()
@@ -225,7 +254,7 @@ def _run_worker_processes(
     for bus_attr, worker_num in jobs:
         proc = ctx.Process(
             target=_process_worker_main,
-            args=(module_name, bus_attr, worker_num, poll_interval, log_level),
+            args=(module_name, bus_attr, worker_num, poll_interval, log_level, concurrency),
             name=f"command-bus-{bus_attr}-{worker_num}",
         )
         proc.start()
@@ -239,10 +268,11 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
 
     parser = argparse.ArgumentParser(
         description=(
-            "Run CommandBus/EventBus.work() in worker processes "
+            "Run CommandBus/EventBus/WorkerApp.work() in worker processes "
             "(fork on POSIX, spawn on Windows). "
-            "Target is module:attribute like uvicorn — e.g. myapp.worker:bus or "
-            "myapp.worker:command_bus_group. If :attribute is omitted, :bus is assumed."
+            "Target is module:attribute like uvicorn — e.g. myapp.worker:app, "
+            "myapp.worker:bus, or myapp.worker:command_bus_group. "
+            "If :attribute is omitted, :bus is assumed."
         )
     )
     parser.add_argument(
@@ -250,7 +280,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
         metavar="TARGET",
         help=(
             "Import path and object: dotted.module:attribute. "
-            "Attribute must be a CommandBus, EventBus, or BusGroup. "
+            "Attribute must be a CommandBus, EventBus, WorkerApp, or BusGroup. "
             "Omit :attribute to use attribute name 'bus' (e.g. myapp.worker is myapp.worker:bus)."
         ),
     )
@@ -260,10 +290,20 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
         default=1,
         metavar="N",
         help=(
-            "Process count for a single CommandBus or EventBus. "
+            "Process count for a single CommandBus, EventBus, or WorkerApp. "
             "For BusGroup, default count when WorkerConfig.workers is omitted (default: 1)"
         ),
     )
+    parser.add_argument(
+        "--concurrency",
+        type=int,
+        default=None,
+        metavar="N",
+        help=(
+            "In-process parallel message dispatch per worker process. "
+            "For WorkerApp, defaults to the app's concurrency when omitted (default: 1 otherwise)"
+        ),
+    )
     parser.add_argument(
         "--poll-interval",
         type=float,
@@ -292,6 +332,8 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
 
     if args.workers < 1:
         parser.error("--workers must be >= 1")
+    if args.concurrency is not None and args.concurrency < 1:
+        parser.error("--concurrency must be >= 1")
 
     module_name, attr_name = _parse_target(args.target)
 
@@ -304,6 +346,20 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     if obj is None:
         raise SystemExit(f"Module {module_name!r} has no attribute {attr_name!r}")
 
+    if isinstance(obj, WorkerApp):
+        concurrency = args.concurrency if args.concurrency is not None else obj.concurrency
+        if isinstance(obj.queue_adapter, InMemoryQueueAdapter) and args.workers > 1:
+            logger.warning(
+                "InMemoryQueueAdapter is process-local; each of %d worker processes "
+                "will have its own queue. Use a shared backend (SQS, Redis, RabbitMQ) "
+                "for multi-process workers, or run with --workers 1.",
+                args.workers,
+            )
+    elif args.concurrency is not None:
+        concurrency = args.concurrency
+    else:
+        concurrency = 1
+
     if isinstance(obj, (BusGroup, CommandBusGroup)):
         obj.validate(mod)
         jobs = obj.iter_jobs(mod, args.workers)
@@ -318,19 +374,20 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
                 attr,
                 qn,
             )
-    elif isinstance(obj, _BUS_TYPES):
+    elif isinstance(obj, _WORKER_TARGET_TYPES):
         jobs = _worker_jobs(attr_name, args.workers)
-        qn = getattr(obj.queue_adapter, "queue_name", attr_name)
+        qn = _queue_name_for_target(obj, attr_name)
         logger.info(
-            "Launching %d process(es) for %s:%s (queue_name=%s)",
+            "Launching %d process(es) for %s:%s (queue_name=%s, concurrency=%d)",
             args.workers,
             module_name,
             attr_name,
             qn,
+            concurrency,
         )
     else:
         raise SystemExit(
-            f"Attribute {attr_name!r} must be a CommandBus, EventBus, or BusGroup "
+            f"Attribute {attr_name!r} must be a CommandBus, EventBus, WorkerApp, or BusGroup "
             f"(got {type(obj).__name__})"
         )
 
@@ -340,6 +397,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
             jobs,
             max(0.0, args.poll_interval),
             log_level,
+            concurrency,
         )
     except KeyboardInterrupt:
         sys.exit(130)

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/src/command_bus/event_bus.py

@@ -1,7 +1,8 @@
 """Pub/sub event bus: publish fans out to all subscribers."""
 
+import asyncio
 import logging
-from typing import Optional, Type
+from typing import Any, Optional, Type
 
 from .interfaces import (
     EventBusInterface,
@@ -66,9 +67,17 @@ class EventBus(EventBusInterface):
                 entry.handler_class,
             )
 
-    async def work(self) -> None:
-        """Poll the subscription and dispatch each message to its handlers."""
-        messages = self.queue_adapter.get_messages()
-        for message in messages:
-            await self.dispatch(message.body)
-            self.queue_adapter.dequeue(message)
+    async def work(self, *, concurrency: int = 1) -> int:
+        """Poll the subscription and dispatch messages (up to ``concurrency`` in parallel)."""
+        messages = self.queue_adapter.get_messages(max_messages=max(1, concurrency))
+        if not messages:
+            return 0
+
+        async def _handle(message: Any) -> None:
+            try:
+                await self.dispatch(message.body)
+            finally:
+                self.queue_adapter.dequeue(message)
+
+        await asyncio.gather(*(_handle(m) for m in messages))
+        return len(messages)

{deegzlibs_command_bus-2.2.0 → deegzlibs_command_bus-2.3.0}/src/command_bus/interfaces.py

@@ -128,7 +128,7 @@ class CommandBusInterface(ABC):
         pass
 
     @abstractmethod
-    async def work(self) -> None:
+    async def work(self, *, concurrency: int = 1) -> int:
         pass
 
 
@@ -151,5 +151,5 @@ class EventBusInterface(ABC):
         pass
 
     @abstractmethod
-    async def work(self) -> None:
+    async def work(self, *, concurrency: int = 1) -> int:
         pass