taskqueue-toolkit 0.1.0__py3-none-any.whl

taskqueue_toolkit/queue/rabbitmq.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import suppress
+from dataclasses import dataclass, field
+
+import aio_pika
+
+from taskqueue_toolkit.queue.dsn import RabbitMqDsn
+from taskqueue_toolkit.queue.task_queue import Decoder, Encoder
+
+logger = logging.getLogger(__name__)
+
+Connect = Callable[[str], Awaitable["aio_pika.abc.AbstractRobustConnection"]]
+
+
+@dataclass(slots=True)
+class RabbitMqQueuedTask[T]:
+    _message: aio_pika.abc.AbstractIncomingMessage
+    task: T
+
+    async def ack(self) -> None:
+        await self._message.ack()
+
+    async def nack(self, *, requeue: bool) -> None:
+        await self._message.nack(requeue=requeue)
+
+
+@dataclass(slots=True)
+class RabbitMqTaskQueue[T]:
+    dsn: RabbitMqDsn
+    encode: Encoder[T]
+    decode: Decoder[T]
+    # Overridable for tests (inject a fake connection) or to share/pool a
+    # connection strategy the caller already has; defaults to the real SDK.
+    connect: Connect = field(default=aio_pika.connect_robust)
+
+    async def publish(self, task: T) -> None:
+        connection = await self.connect(self.dsn.url)
+        try:
+            channel = await connection.channel()
+            queue = await channel.declare_queue(self.dsn.queue_name, durable=True)
+            await channel.default_exchange.publish(
+                aio_pika.Message(
+                    body=self.encode(task),
+                    delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
+                ),
+                routing_key=queue.name,
+            )
+            logger.info("task published", extra={"queue": self.dsn.queue_name})
+        finally:
+            await connection.close()
+
+    async def consume(self) -> AsyncIterator[RabbitMqQueuedTask[T]]:
+        connection = await self.connect(self.dsn.url)
+        try:
+            channel = await connection.channel()
+            await channel.set_qos(prefetch_count=1)
+            queue = await channel.declare_queue(self.dsn.queue_name, durable=True)
+
+            async for message in queue.iterator():
+                yield RabbitMqQueuedTask(_message=message, task=self.decode(message.body))
+        finally:
+            # The consumer (a worker's `async for`) can stop iterating at any
+            # point — graceful shutdown, an unhandled error, etc. — which
+            # raises GeneratorExit right here, inside the yield above. At
+            # that point there's no time left to round-trip a clean
+            # basic.cancel RPC with the broker (the event loop is usually
+            # already shutting down too), so don't try — just drop the
+            # connection. RabbitMQ notices the disconnect and requeues
+            # whatever message was left unacknowledged.
+            with suppress(Exception):
+                await connection.close()

taskqueue_toolkit/queue/redis_streams.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass, field
+from typing import cast
+
+import redis.asyncio as redis
+from redis.exceptions import ResponseError
+
+from taskqueue_toolkit.queue.dsn import RedisStreamsDsn
+from taskqueue_toolkit.queue.task_queue import Decoder, Encoder
+
+logger = logging.getLogger(__name__)
+
+_LONG_POLL_BLOCK_MS = 10_000
+_FIELD = "payload"
+
+ClientFactory = Callable[[RedisStreamsDsn], "redis.Redis"]
+
+
+def _default_client_factory(dsn: RedisStreamsDsn) -> redis.Redis:
+    return redis.Redis.from_url(dsn.url)
+
+
+@dataclass(slots=True)
+class RedisStreamsQueuedTask[T]:
+    _redis: redis.Redis
+    _stream: str
+    _group: str
+    _message_id: str
+    task: T
+
+    async def ack(self) -> None:
+        await self._redis.xack(self._stream, self._group, self._message_id)
+
+    async def nack(self, *, requeue: bool) -> None:
+        if requeue:
+            # Leaving the message unacknowledged (in the group's Pending
+            # Entries List) is enough — consume()'s next pass re-reads
+            # pending entries (id="0") before new ones, so it's redelivered
+            # without needing an explicit "give it back" call the way SQS's
+            # change_message_visibility does.
+            return
+        # No per-message dead-letter action here either — same reasoning as
+        # SQS: permanently dropping a task means removing it from the PEL,
+        # same as a successful ack.
+        await self._redis.xack(self._stream, self._group, self._message_id)
+
+
+@dataclass(slots=True)
+class RedisStreamsTaskQueue[T]:
+    dsn: RedisStreamsDsn
+    encode: Encoder[T]
+    decode: Decoder[T]
+    # Overridable for tests (inject a fake client) or a shared/pooled
+    # connection the caller already manages; defaults to a fresh connection
+    # from the DSN's URL per call, matching the real SDK's usual usage.
+    client_factory: ClientFactory = field(default=_default_client_factory)
+
+    def _client(self) -> redis.Redis:
+        return self.client_factory(self.dsn)
+
+    async def _ensure_group(self, client: redis.Redis) -> None:
+        try:
+            await client.xgroup_create(self.dsn.stream_name, self.dsn.group, id="0", mkstream=True)
+        except ResponseError as exc:
+            if "BUSYGROUP" not in str(exc):
+                raise
+
+    async def publish(self, task: T) -> None:
+        client = self._client()
+        try:
+            await client.xadd(self.dsn.stream_name, {_FIELD: self.encode(task)})
+            logger.info("task published", extra={"stream": self.dsn.stream_name})
+        finally:
+            await client.aclose()
+
+    async def consume(self) -> AsyncIterator[RedisStreamsQueuedTask[T]]:
+        client = self._client()
+        try:
+            await self._ensure_group(client)
+            stream = self.dsn.stream_name
+            group = self.dsn.group
+            consumer = self.dsn.consumer
+
+            while True:
+                # Re-deliver our own still-pending entries first (id="0") —
+                # covers a crash between XREADGROUP and XACK on a previous
+                # run — then fall through to new entries (id=">").
+                for read_id in ("0", ">"):
+                    # redis-py's XReadGroupResponse type is a broad union
+                    # (it also covers the decode_responses=True str shape);
+                    # without decode_responses the actual shape is always
+                    # this nested list of (stream_name, entries) in bytes.
+                    raw_response = await client.xreadgroup(
+                        group,
+                        consumer,
+                        {stream: read_id},
+                        count=1,
+                        block=_LONG_POLL_BLOCK_MS if read_id == ">" else None,
+                    )
+                    response = cast(
+                        "list[tuple[bytes, list[tuple[bytes, dict[bytes, bytes]]]]]",
+                        raw_response,
+                    )
+                    for _stream_name, messages in response:
+                        for message_id, fields in messages:
+                            yield RedisStreamsQueuedTask(
+                                _redis=client,
+                                _stream=stream,
+                                _group=group,
+                                _message_id=message_id.decode(),
+                                task=self.decode(fields[_FIELD.encode()]),
+                            )
+        finally:
+            await client.aclose()

taskqueue_toolkit/queue/registry.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+from urllib.parse import urlsplit
+
+from taskqueue_toolkit.queue.task_queue import Decoder, Encoder, TaskQueue
+
+# A handler takes the full DSN string plus this call's encode/decode pair
+# and returns a ready-to-use TaskQueue — parsing and construction happen
+# together so registering a broker is one call, not a parser plus a
+# separate constructor to keep in sync.
+TaskQueueHandler = Callable[[str, Encoder[Any], Decoder[Any]], TaskQueue[Any]]
+
+_registry: dict[str, TaskQueueHandler] = {}
+
+
+class SchemeAlreadyRegisteredError(Exception):
+    def __init__(self, scheme: str) -> None:
+        super().__init__(
+            f"A handler is already registered for scheme {scheme!r}. "
+            "Each scheme can only map to one broker handler."
+        )
+
+
+def register_scheme(scheme: str, handler: TaskQueueHandler) -> None:
+    """Make create_task_queue() recognize a DSN scheme this package doesn't
+    ship a built-in adapter for (e.g. "kafka://...").
+
+    This is the extension point for brokers outside the five this package
+    integrates directly (amqp/redis/sqs/sns/pubsub, handled internally and
+    checked for exhaustiveness by mypy) — a consumer that needs a broker
+    this package doesn't know about registers it once, at import/startup
+    time, instead of forking the package.
+    """
+    if scheme in _registry:
+        raise SchemeAlreadyRegisteredError(scheme)
+    _registry[scheme] = handler
+
+
+def unregister_scheme(scheme: str) -> None:
+    """Mainly useful for tests that register a fake handler and want to
+    clean up afterwards."""
+    _registry.pop(scheme, None)
+
+
+def resolve_registered_scheme(dsn: str) -> TaskQueueHandler | None:
+    """Look up a handler registered via register_scheme() for this DSN's
+    scheme, or None if nothing is registered for it (including every scheme
+    this package already handles internally — those never reach the
+    registry)."""
+    scheme = urlsplit(dsn).scheme
+    return _registry.get(scheme)

taskqueue_toolkit/queue/sns.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from collections.abc import AsyncIterator, Callable
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from dataclasses import dataclass, field
+
+import aioboto3
+from types_aiobotocore_sns.client import SNSClient
+from types_aiobotocore_sqs.client import SQSClient
+
+from taskqueue_toolkit.queue.aws_session import aws_session_kwargs
+from taskqueue_toolkit.queue.dsn import SnsDsn
+from taskqueue_toolkit.queue.task_queue import Decoder, Encoder
+
+logger = logging.getLogger(__name__)
+
+_LONG_POLL_WAIT_SECONDS = 10
+_SUBSCRIBER_QUEUE_SUFFIX = "-subscriber"
+
+ClientFactory = Callable[[SnsDsn], AbstractAsyncContextManager[tuple[SNSClient, SQSClient]]]
+
+
+@asynccontextmanager
+async def _default_client_factory(dsn: SnsDsn) -> AsyncIterator[tuple[SNSClient, SQSClient]]:
+    session = aioboto3.Session()
+    async with (
+        session.client("sns", **aws_session_kwargs(dsn)) as sns,
+        session.client("sqs", **aws_session_kwargs(dsn)) as sqs,
+    ):
+        yield sns, sqs
+
+
+def _sqs_policy_allowing_sns_publish(queue_arn: str, topic_arn: str) -> str:
+    return json.dumps(
+        {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": {"Service": "sns.amazonaws.com"},
+                    "Action": "sqs:SendMessage",
+                    "Resource": queue_arn,
+                    "Condition": {"ArnEquals": {"aws:SourceArn": topic_arn}},
+                }
+            ],
+        }
+    )
+
+
+def _unwrap_sns_envelope(body: str) -> str:
+    """SNS-to-SQS delivery wraps the published message in a JSON envelope
+    (Type, MessageId, TopicArn, Message, Timestamp, Signature, ...) — the
+    payload we actually published is in the "Message" field."""
+    return str(json.loads(body)["Message"])
+
+
+@dataclass(slots=True)
+class SnsQueuedTask[T]:
+    _client: SQSClient
+    _queue_url: str
+    _receipt_handle: str
+    task: T
+
+    async def ack(self) -> None:
+        await self._client.delete_message(
+            QueueUrl=self._queue_url, ReceiptHandle=self._receipt_handle
+        )
+
+    async def nack(self, *, requeue: bool) -> None:
+        if requeue:
+            await self._client.change_message_visibility(
+                QueueUrl=self._queue_url,
+                ReceiptHandle=self._receipt_handle,
+                VisibilityTimeout=0,
+            )
+        else:
+            await self._client.delete_message(
+                QueueUrl=self._queue_url, ReceiptHandle=self._receipt_handle
+            )
+
+
+@dataclass(slots=True)
+class SnsTaskQueue[T]:
+    """SNS is fan-out only — there's no receive/consume on a topic itself.
+
+    consume() needs a queue to actually poll, so this adapter provisions one
+    dedicated SQS queue subscribed to the topic (both create_topic and
+    subscribe are idempotent in the AWS API, so calling this on every
+    publish()/consume() is safe — no separate "already set up" state to
+    track). publish() only ever talks to SNS; consume() only ever talks to
+    the subscriber queue.
+    """
+
+    dsn: SnsDsn
+    encode: Encoder[T]
+    decode: Decoder[T]
+    # Overridable for tests (inject fake clients) or a shared/pooled session
+    # the caller already manages; defaults to a fresh aioboto3 session per
+    # call, matching the real SDK's usual usage.
+    client_factory: ClientFactory = field(default=_default_client_factory)
+
+    async def _get_or_create_topic_arn(self, sns: SNSClient) -> str:
+        response = await sns.create_topic(Name=self.dsn.topic_name)
+        return response["TopicArn"]
+
+    async def _get_or_create_subscriber_queue(
+        self, sqs: SQSClient, sns: SNSClient, topic_arn: str
+    ) -> str:
+        queue_name = self.dsn.topic_name + _SUBSCRIBER_QUEUE_SUFFIX
+        try:
+            queue_url = (await sqs.get_queue_url(QueueName=queue_name))["QueueUrl"]
+        except sqs.exceptions.QueueDoesNotExist:
+            queue_url = (await sqs.create_queue(QueueName=queue_name))["QueueUrl"]
+
+        queue_arn = (
+            await sqs.get_queue_attributes(QueueUrl=queue_url, AttributeNames=["QueueArn"])
+        )["Attributes"]["QueueArn"]
+
+        await sqs.set_queue_attributes(
+            QueueUrl=queue_url,
+            Attributes={"Policy": _sqs_policy_allowing_sns_publish(queue_arn, topic_arn)},
+        )
+        await sns.subscribe(TopicArn=topic_arn, Protocol="sqs", Endpoint=queue_arn)
+        return queue_url
+
+    async def publish(self, task: T) -> None:
+        async with self.client_factory(self.dsn) as (sns, sqs):
+            topic_arn = await self._get_or_create_topic_arn(sns)
+            # SNS fan-out only delivers to subscribers that already exist at
+            # publish time — a message published before the subscriber queue
+            # is provisioned is silently dropped, unlike RabbitMQ/SQS/Redis
+            # Streams where publishing ahead of any consumer still keeps the
+            # message. Ensuring the subscription here, not just in consume(),
+            # is what makes the first publish after a cold deploy not lose
+            # its message.
+            await self._get_or_create_subscriber_queue(sqs, sns, topic_arn)
+            message = base64.b64encode(self.encode(task)).decode()
+            await sns.publish(TopicArn=topic_arn, Message=message)
+            logger.info("task published", extra={"topic": self.dsn.topic_name})
+
+    async def consume(self) -> AsyncIterator[SnsQueuedTask[T]]:
+        async with self.client_factory(self.dsn) as (sns, sqs):
+            topic_arn = await self._get_or_create_topic_arn(sns)
+            queue_url = await self._get_or_create_subscriber_queue(sqs, sns, topic_arn)
+
+            while True:
+                response = await sqs.receive_message(
+                    QueueUrl=queue_url,
+                    MaxNumberOfMessages=1,
+                    WaitTimeSeconds=_LONG_POLL_WAIT_SECONDS,
+                )
+                for message in response.get("Messages", []):
+                    envelope = _unwrap_sns_envelope(message["Body"])
+                    yield SnsQueuedTask(
+                        _client=sqs,
+                        _queue_url=queue_url,
+                        _receipt_handle=message["ReceiptHandle"],
+                        task=self.decode(base64.b64decode(envelope)),
+                    )

taskqueue_toolkit/queue/sqs.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import base64
+import logging
+from collections.abc import AsyncIterator, Callable
+from contextlib import AbstractAsyncContextManager
+from dataclasses import dataclass, field
+from typing import cast
+
+import aioboto3
+from types_aiobotocore_sqs.client import SQSClient
+
+from taskqueue_toolkit.queue.aws_session import aws_session_kwargs
+from taskqueue_toolkit.queue.dsn import SqsDsn
+from taskqueue_toolkit.queue.task_queue import Decoder, Encoder
+
+logger = logging.getLogger(__name__)
+
+_LONG_POLL_WAIT_SECONDS = 10
+
+ClientFactory = Callable[[SqsDsn], AbstractAsyncContextManager[SQSClient]]
+
+
+def _default_client_factory(dsn: SqsDsn) -> AbstractAsyncContextManager[SQSClient]:
+    return cast(
+        "AbstractAsyncContextManager[SQSClient]",
+        aioboto3.Session().client("sqs", **aws_session_kwargs(dsn)),
+    )
+
+
+@dataclass(slots=True)
+class SqsQueuedTask[T]:
+    _client: SQSClient
+    _queue_url: str
+    _receipt_handle: str
+    task: T
+
+    async def ack(self) -> None:
+        await self._client.delete_message(
+            QueueUrl=self._queue_url, ReceiptHandle=self._receipt_handle
+        )
+
+    async def nack(self, *, requeue: bool) -> None:
+        if requeue:
+            # Make the message immediately visible again instead of waiting
+            # out its VisibilityTimeout — SQS has no direct "nack" RPC, this
+            # is the idiomatic way to force redelivery on demand.
+            await self._client.change_message_visibility(
+                QueueUrl=self._queue_url,
+                ReceiptHandle=self._receipt_handle,
+                VisibilityTimeout=0,
+            )
+        else:
+            # SQS has no per-call dead-letter action; permanently dropping a
+            # task means removing it the same way a successful ack does. A
+            # queue-level DLQ (RedrivePolicy) is a deployment concern, not
+            # something this adapter configures per message.
+            await self._client.delete_message(
+                QueueUrl=self._queue_url, ReceiptHandle=self._receipt_handle
+            )
+
+
+@dataclass(slots=True)
+class SqsTaskQueue[T]:
+    dsn: SqsDsn
+    encode: Encoder[T]
+    decode: Decoder[T]
+    # Overridable for tests (inject a fake client) or a shared/pooled
+    # session the caller already manages; defaults to a fresh aioboto3
+    # session per call, matching the real SDK's usual usage.
+    client_factory: ClientFactory = field(default=_default_client_factory)
+
+    async def _get_queue_url(self, client: SQSClient) -> str:
+        try:
+            response = await client.get_queue_url(QueueName=self.dsn.queue_name)
+        except client.exceptions.QueueDoesNotExist:
+            response = await client.create_queue(QueueName=self.dsn.queue_name)
+        return response["QueueUrl"]
+
+    async def publish(self, task: T) -> None:
+        async with self.client_factory(self.dsn) as client:
+            queue_url = await self._get_queue_url(client)
+            body = base64.b64encode(self.encode(task)).decode()
+            await client.send_message(QueueUrl=queue_url, MessageBody=body)
+            logger.info("task published", extra={"queue": self.dsn.queue_name})
+
+    async def consume(self) -> AsyncIterator[SqsQueuedTask[T]]:
+        async with self.client_factory(self.dsn) as client:
+            queue_url = await self._get_queue_url(client)
+
+            while True:
+                response = await client.receive_message(
+                    QueueUrl=queue_url,
+                    MaxNumberOfMessages=1,
+                    WaitTimeSeconds=_LONG_POLL_WAIT_SECONDS,
+                )
+                for message in response.get("Messages", []):
+                    yield SqsQueuedTask(
+                        _client=client,
+                        _queue_url=queue_url,
+                        _receipt_handle=message["ReceiptHandle"],
+                        task=self.decode(base64.b64decode(message["Body"])),
+                    )

taskqueue_toolkit/queue/task_queue.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Callable
+from typing import Protocol, TypeVar
+
+T = TypeVar("T")
+T_co = TypeVar("T_co", covariant=True)
+
+Encoder = Callable[[T], bytes]
+Decoder = Callable[[bytes], T]
+
+
+class QueuedTask(Protocol[T_co]):
+    """A task handed to a consumer, together with how to close it out.
+
+    ack() and nack() are the only broker-specific detail a consumer needs:
+    the concrete queue implementation decides what "acknowledged" or
+    "requeue this" actually means (delete from RabbitMQ, delete from SQS,
+    reset a Redis Streams pending entry, ...).
+    """
+
+    @property
+    def task(self) -> T_co: ...
+
+    async def ack(self) -> None:
+        """Mark the task as successfully processed."""
+        ...
+
+    async def nack(self, *, requeue: bool) -> None:
+        """Mark the task as failed. requeue=True retries it; False drops it
+        for good (or routes it to a dead-letter destination, if the broker
+        and its configuration support one — this call itself never
+        configures that, only triggers the broker's existing behavior)."""
+        ...
+
+
+class TaskQueue(Protocol[T]):
+    """A broker-agnostic queue of tasks of type T.
+
+    Deliberately minimal — publish(), consume() (an AsyncIterator of
+    QueuedTask[T]), and ack()/nack(requeue=...) on each received task — so it
+    stays implementable by brokers with very different delivery models
+    (AMQP queues, SQS, SNS fan-out, Redis Streams consumer groups, Pub/Sub)
+    without the contract assuming anything specific to one of them: no
+    routing keys, no topics/partitions, no consumer groups, no FIFO groups.
+
+    T is never assumed to be any particular shape. Each concrete
+    implementation is handed an Encoder[T]/Decoder[T] pair at construction
+    time — this package has no opinion on how your task type serializes,
+    only on how it moves through a queue once serialized.
+    """
+
+    async def publish(self, task: T) -> None:
+        """Enqueue a task for a consumer to pick up."""
+        ...
+
+    def consume(self) -> AsyncIterator[QueuedTask[T]]:
+        """Yield tasks as they become available, one at a time. Each yielded
+        task must be ack()'d or nack()'d by the consumer — the queue
+        implementation decides what happens to a task that's never
+        acknowledged (redelivery, visibility timeout expiry, etc.)."""
+        ...

taskqueue_toolkit/testing/__init__.py

@@ -0,0 +1,58 @@
+"""In-memory doubles of each broker adapter, for testing code that uses
+this package without a real RabbitMQ/SQS/SNS/Redis/Pub-Sub.
+
+Each Fake*Broker is a real, working implementation of the relevant slice of
+its SDK — not a call-recording mock — so it exercises the same code paths
+(FIFO ordering, ack/nack, consumer groups, fan-out, ...) a real broker
+would. Create one instance per test; there is no global state to reset.
+
+Importing a given Fake*Broker requires the same optional extra as the
+adapter it doubles (e.g. FakeRabbitMqBroker needs no extra since it has no
+SDK dependency of its own, but FakeRedisStreamsBroker needs
+`pip install taskqueue-toolkit[redis-streams]`, FakeSqsBroker/FakeSnsBroker
+need `[aws]`, FakePubsubBroker needs `[pubsub]`) — this module only imports
+the specific fake actually accessed, via module-level __getattr__, so
+`import taskqueue_toolkit.testing` itself never requires every extra to be
+installed at once.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from taskqueue_toolkit.testing.pubsub import FakePubsubBroker
+    from taskqueue_toolkit.testing.rabbitmq import FakeRabbitMqBroker
+    from taskqueue_toolkit.testing.redis_streams import FakeRedisStreamsBroker
+    from taskqueue_toolkit.testing.sns import FakeSnsBroker
+    from taskqueue_toolkit.testing.sqs import FakeSqsBroker
+
+__all__ = [
+    "FakePubsubBroker",
+    "FakeRabbitMqBroker",
+    "FakeRedisStreamsBroker",
+    "FakeSnsBroker",
+    "FakeSqsBroker",
+]
+
+_EXPORTS = {
+    "FakePubsubBroker": ("taskqueue_toolkit.testing.pubsub", "FakePubsubBroker"),
+    "FakeRabbitMqBroker": ("taskqueue_toolkit.testing.rabbitmq", "FakeRabbitMqBroker"),
+    "FakeRedisStreamsBroker": (
+        "taskqueue_toolkit.testing.redis_streams",
+        "FakeRedisStreamsBroker",
+    ),
+    "FakeSnsBroker": ("taskqueue_toolkit.testing.sns", "FakeSnsBroker"),
+    "FakeSqsBroker": ("taskqueue_toolkit.testing.sqs", "FakeSqsBroker"),
+}
+
+
+def __getattr__(name: str) -> object:
+    try:
+        module_name, attr_name = _EXPORTS[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+    import importlib
+
+    module = importlib.import_module(module_name)
+    return getattr(module, attr_name)