async-task-api-worker 0.1.0rc2__py3-none-any.whl

async_task_api_worker/_runtime/progress.py

@@ -0,0 +1,143 @@
+"""Progress reporting: validation and a time-based throttle.
+
+Progress is the **latest state**, not an event stream. Rules:
+
+- leading edge: the first update, and any update arriving after ``min_interval_s`` of silence, is published at once;
+- trailing flush: an update arriving sooner is held, a later one replaces it (latest wins), and the survivor is
+  published when the interval has elapsed;
+- the fraction stays in ``[0, 1)``: the terminal success or failure message is the 100%;
+- closing the reporter cancels any pending flush and refuses every later update, so no progress is ever published
+  after the terminal message.
+"""
+
+import asyncio
+import logging
+import time
+from collections.abc import Awaitable, Callable
+from typing import Final
+
+from async_task_api_worker._runtime.observer import ProgressDropReason, RuntimeObserver
+from async_task_api_worker.protocol.json_types import ProgressPayload
+from async_task_api_worker.protocol.messages import InvalidProgressError, MessageEncoder
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("async_task_api_worker")
+# A reason that is normal operation, not worth a log line.
+_SILENT_REASONS: Final[frozenset[ProgressDropReason]] = frozenset({ProgressDropReason.COALESCED})
+
+type Clock = Callable[[], float]
+type Sleep = Callable[[float], Awaitable[None]]
+type PublishBody = Callable[[bytes], Awaitable[None]]
+
+
+class ProgressDropLog:
+    """Counts every dropped update and warns once per reason per process."""
+
+    def __init__(self, observer: RuntimeObserver) -> None:
+        self._observer = observer
+        self._warned: set[ProgressDropReason] = set()
+
+    def dropped(self, reason: ProgressDropReason, task_id: str) -> None:
+        self._observer.progress_dropped(reason)
+        if reason in _SILENT_REASONS or reason in self._warned:
+            return
+        self._warned.add(reason)
+        _LOGGER.warning(
+            "Progress update dropped (%s), task_id=%s. Further drops of this kind are not logged.",
+            reason,
+            task_id,
+        )
+
+
+class ProgressReporter:
+    """Per-task progress gate. ``publish`` must never raise: a failed progress publish never fails the task."""
+
+    def __init__(
+        self,
+        *,
+        task_id: str,
+        encoder: MessageEncoder,
+        publish: PublishBody,
+        min_interval_s: float,
+        drops: ProgressDropLog,
+        clock: Clock = time.monotonic,
+        sleep: Sleep = asyncio.sleep,
+    ) -> None:
+        self._task_id = task_id
+        self._encoder = encoder
+        self._publish = publish
+        self._min_interval_s = min_interval_s
+        self._drops = drops
+        self._clock = clock
+        self._sleep = sleep
+        self._lock = asyncio.Lock()
+        self._closed = False
+        self._high_water = 0.0
+        self._last_publish: float | None = None
+        self._pending: bytes | None = None
+        self._flush_task: asyncio.Task[None] | None = None
+
+    async def report(self, fraction: float, payload: ProgressPayload | None = None) -> None:
+        """Validate, then publish now or hold for the trailing flush. Never raises."""
+        if self._closed:
+            self._drops.dropped(ProgressDropReason.AFTER_CONCLUSION, self._task_id)
+            return
+        try:
+            body = self._encoder.progress(self._task_id, fraction, payload)
+        except InvalidProgressError:
+            self._drops.dropped(ProgressDropReason.INVALID_FRACTION, self._task_id)
+            return
+        except ValueError:
+            self._drops.dropped(ProgressDropReason.INVALID_PAYLOAD, self._task_id)
+            return
+        if fraction < self._high_water:
+            self._drops.dropped(ProgressDropReason.NOT_INCREASING, self._task_id)
+            return
+        self._high_water = fraction
+
+        now = self._clock()
+        if self._flush_task is None and self._is_due(now):
+            self._last_publish = now
+            await self._publish_now(body)
+            return
+        if self._pending is not None:
+            self._drops.dropped(ProgressDropReason.COALESCED, self._task_id)
+        self._pending = body
+        if self._flush_task is None:
+            self._flush_task = asyncio.get_running_loop().create_task(self._flush_loop())
+
+    async def close(self) -> None:
+        """Cancel the pending flush and wait for a publish in progress: nothing is published afterwards."""
+        self._closed = True
+        task = self._flush_task
+        if task is not None:
+            task.cancel()
+            await asyncio.wait({task})
+        if self._pending is not None:
+            self._pending = None
+            self._drops.dropped(ProgressDropReason.AFTER_CONCLUSION, self._task_id)
+        async with self._lock:
+            pass
+
+    def _is_due(self, now: float) -> bool:
+        return self._last_publish is None or now - self._last_publish >= self._min_interval_s
+
+    async def _publish_now(self, body: bytes) -> None:
+        async with self._lock:
+            if self._closed:
+                self._drops.dropped(ProgressDropReason.AFTER_CONCLUSION, self._task_id)
+                return
+            await self._publish(body)
+
+    async def _flush_loop(self) -> None:
+        try:
+            while self._pending is not None:
+                last = self._last_publish if self._last_publish is not None else self._clock()
+                delay = last + self._min_interval_s - self._clock()
+                if delay > 0:
+                    await self._sleep(delay)
+                body, self._pending = self._pending, None
+                assert body is not None  # only close() clears it, and close() cancels this task first
+                self._last_publish = self._clock()
+                await self._publish_now(body)
+        finally:
+            self._flush_task = None

async_task_api_worker/_runtime/retry.py

@@ -0,0 +1,29 @@
+"""Attempt numbering and retry backoff."""
+
+import random
+from collections.abc import Callable
+from typing import Final
+
+from async_task_api_worker._runtime.transport import Delivery
+
+_FIRST_ATTEMPT: Final[int] = 1
+_REDELIVERED_ATTEMPT: Final[int] = 2
+# Beyond this the exponential term overflows a float long before it matters: the cap is reached much earlier.
+_MAX_EXPONENT: Final[int] = 60
+_JITTER_LOW: Final[float] = 0.5
+_JITTER_HIGH: Final[float] = 1.0
+
+type Uniform = Callable[[float, float], float]
+
+
+def attempt_of(delivery: Delivery) -> int:
+    """1-based delivery attempt: ``x-delivery-count + 1`` when the broker provides it, else a redelivery guess."""
+    if delivery.delivery_count is not None:
+        return delivery.delivery_count + 1
+    return _REDELIVERED_ATTEMPT if delivery.redelivered else _FIRST_ATTEMPT
+
+
+def backoff_seconds(attempt: int, *, base_s: float, max_s: float, uniform: Uniform = random.uniform) -> float:
+    """``min(base * 2**(attempt-1), max) * uniform(0.5, 1.0)``."""
+    exponent = min(max(attempt - 1, 0), _MAX_EXPONENT)
+    return min(base_s * 2.0**exponent, max_s) * uniform(_JITTER_LOW, _JITTER_HIGH)

async_task_api_worker/_runtime/sync_bridge.py

@@ -0,0 +1,68 @@
+"""Running ``def`` handlers off the event loop, with thread-safe progress and cooperative cancellation."""
+
+import asyncio
+import concurrent.futures
+import contextvars
+import logging
+from collections.abc import Callable
+from typing import Final
+
+from async_task_api_worker._runtime.progress import ProgressReporter
+from async_task_api_worker.protocol.json_types import ProgressPayload
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("async_task_api_worker")
+# A progress publish that takes longer than this is abandoned: the thread must not hang on telemetry.
+PROGRESS_PUBLISH_TIMEOUT_S: Final[float] = 5.0
+
+type ThreadSafeProgress = Callable[[float, ProgressPayload | None], None]
+
+
+class TaskCancelledError(Exception):
+    """Raised by ``SyncTaskContext.raise_if_cancelled``. The engine handles it: the task already concluded."""
+
+
+def make_threadsafe_progress(
+    loop: asyncio.AbstractEventLoop,
+    reporter: ProgressReporter,
+    *,
+    timeout_s: float = PROGRESS_PUBLISH_TIMEOUT_S,
+) -> ThreadSafeProgress:
+    """Progress callable for a worker thread: runs on the worker loop, never creates one, never raises."""
+
+    def report(fraction: float, payload: ProgressPayload | None = None) -> None:
+        coroutine = reporter.report(fraction, payload)
+        try:
+            future = asyncio.run_coroutine_threadsafe(coroutine, loop)
+        except RuntimeError:
+            coroutine.close()
+            _LOGGER.warning("Progress dropped: the event loop is closed.")
+            return
+        try:
+            future.result(timeout=timeout_s)
+        except concurrent.futures.TimeoutError:
+            future.cancel()
+            _LOGGER.warning("Progress dropped: the publish took more than %s s.", timeout_s)
+        except Exception:
+            _LOGGER.exception("Progress dropped: the publish failed.")
+
+    return report
+
+
+class SyncBridge:
+    """Dedicated thread pool for sync handlers, sized like the concurrency (never the default executor)."""
+
+    def __init__(self, max_workers: int) -> None:
+        self._executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=max_workers,
+            thread_name_prefix="async-task-api-worker",
+        )
+
+    def submit[T](self, loop: asyncio.AbstractEventLoop, call: Callable[[], T]) -> asyncio.Future[T]:
+        # ``run_in_executor`` does not carry the context over: the thread runs in a copy of the caller's, so that the
+        # task bound for the logs (and anything else a handler's libraries put there) is visible in it.
+        context = contextvars.copy_context()
+        return loop.run_in_executor(self._executor, context.run, call)
+
+    def shutdown(self) -> None:
+        """Do not wait for threads that are stuck in a handler: the pod restart reclaims them."""
+        self._executor.shutdown(wait=False, cancel_futures=True)

async_task_api_worker/_runtime/transport.py

@@ -0,0 +1,62 @@
+"""The two transport protocols the engine runs on. The broker adapter and the in-memory broker implement them."""
+
+from collections.abc import Callable
+from typing import Final, Protocol
+
+# Closing the connection (or discarding a half-built one) against a broker that is restarting or half-open can wait on
+# the AMQP close handshake: give up after this. The process exit closes the socket and the broker requeues what is
+# unacked.
+CLOSE_TIMEOUT_S: Final[float] = 5.0
+
+
+class Delivery(Protocol):
+    """One message received from the input queue, to be acked or nacked exactly once."""
+
+    @property
+    def body(self) -> bytes: ...
+
+    @property
+    def delivery_count(self) -> int | None:
+        """How many times the broker already handed this message out (quorum queues), ``None`` when unknown."""
+        ...
+
+    @property
+    def redelivered(self) -> bool: ...
+
+    async def ack(self) -> None: ...
+
+    async def nack(self, *, requeue: bool) -> None: ...
+
+
+class Publisher(Protocol):
+    """Publishes on the output queue. Persistent and publisher-confirmed: it raises when the publish failed."""
+
+    async def publish(self, body: bytes) -> None: ...
+
+
+type OnDelivery = Callable[[Delivery], None]
+
+
+class TransportUnavailableError(Exception):
+    """The broker cannot be reached (yet): starting the transport may be retried."""
+
+
+class Transport(Protocol):
+    """A broker connection: declares the queues, delivers messages and publishes results."""
+
+    @property
+    def publisher(self) -> Publisher: ...
+
+    async def start(self, on_delivery: OnDelivery) -> None:
+        """Declare the queues, connect and start consuming. Raises :class:`TransportUnavailableError`."""
+        ...
+
+    async def ping(self, timeout_s: float) -> bool:
+        """Whether the broker connection is up right now (``False`` before ``start`` and after ``close``)."""
+        ...
+
+    async def stop_consuming(self) -> None:
+        """Stop receiving new deliveries (``basic.cancel``). Acks and publishes keep working."""
+        ...
+
+    async def close(self) -> None: ...

async_task_api_worker/_version.py

@@ -0,0 +1,11 @@
+"""Installed distribution version."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+_DISTRIBUTION_NAME = "async-task-api-worker"
+_UNKNOWN_VERSION = "0.0.0+unknown"
+
+try:
+    __version__: str = version(_DISTRIBUTION_NAME)
+except PackageNotFoundError:  # pragma: no cover - only when run from a bare source tree
+    __version__ = _UNKNOWN_VERSION

async_task_api_worker/cli.py

@@ -0,0 +1,88 @@
+"""Command line: ``async-task-api-worker run <module:attr>``."""
+
+import argparse
+import importlib
+import inspect
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Final
+
+from async_task_api_worker._runtime.lifecycle import EXIT_CONFIGURATION, EXIT_FAILURE, EXIT_OK, run_blocking
+from async_task_api_worker.errors import WorkerConfigurationError, WorkerDefinitionError
+from async_task_api_worker.worker import Worker
+
+__all__ = ["EXIT_CONFIGURATION", "EXIT_FAILURE", "EXIT_OK", "load_worker", "main"]
+
+_PROG: Final[str] = "async-task-api-worker"
+_COMMAND_RUN: Final[str] = "run"
+_TARGET_SEPARATOR: Final[str] = ":"
+_DEFINITION_ERRORS: Final[tuple[type[Exception], ...]] = (WorkerDefinitionError, WorkerConfigurationError)
+
+
+class TargetError(Exception):
+    """The ``module:attr`` target cannot be turned into a worker."""
+
+
+def _working_directory_first() -> None:
+    """Like uvicorn: modules next to where the command is run can be imported."""
+    working_directory = str(Path.cwd())
+    if working_directory not in sys.path:
+        sys.path.insert(0, working_directory)
+
+
+def load_worker(target: str) -> Worker:
+    """Import ``module:attr``: ``attr`` is a ``Worker`` or a zero-argument factory function returning one."""
+    module_name, separator, attribute = target.partition(_TARGET_SEPARATOR)
+    if not separator or not module_name or not attribute:
+        msg = f"Invalid target {target!r}: expected module:attr"
+        raise TargetError(msg)
+    _working_directory_first()
+    try:
+        module = importlib.import_module(module_name)
+    except ImportError as error:
+        msg = f"Cannot import module {module_name!r}: {error}"
+        raise TargetError(msg) from error
+    except _DEFINITION_ERRORS as error:
+        msg = f"Invalid worker definition in module {module_name!r}: {error}"
+        raise TargetError(msg) from error
+    try:
+        candidate = getattr(module, attribute)
+    except AttributeError as error:
+        msg = f"Module {module_name!r} has no attribute {attribute!r}"
+        raise TargetError(msg) from error
+    if inspect.isfunction(candidate):
+        try:
+            candidate = candidate()
+        except _DEFINITION_ERRORS as error:
+            msg = f"Invalid worker definition in {target!r}: {error}"
+            raise TargetError(msg) from error
+        except TypeError as error:
+            msg = f"{target!r} cannot be called without arguments: {error}"
+            raise TargetError(msg) from error
+    if not isinstance(candidate, Worker):
+        msg = f"{target!r} is neither a Worker nor a zero-argument factory function returning one"
+        raise TargetError(msg)
+    return candidate
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog=_PROG, description="Tools for AsyncTaskAPI workers.")
+    commands = parser.add_subparsers(dest="command", required=True)
+    run = commands.add_parser(_COMMAND_RUN, help="run a worker until SIGTERM or SIGINT")
+    run.add_argument("target", help="module:attr, a Worker or a zero-argument factory returning one")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Entry point. Exit codes: 0 ok, 1 failure, 2 usage or configuration error."""
+    try:
+        arguments = _parser().parse_args(argv)
+    except SystemExit as error:
+        return error.code if isinstance(error.code, int) else EXIT_CONFIGURATION
+    try:
+        worker = load_worker(arguments.target)
+    except TargetError as error:
+        sys.stderr.write(f"{_PROG}: {error}\n")
+        return EXIT_CONFIGURATION
+    return run_blocking(worker)

async_task_api_worker/context.py

@@ -0,0 +1,70 @@
+"""What a handler receives next to its input: identity, deadline, logger, inputs and progress reporting."""
+
+import logging
+import threading
+import time
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass, field
+
+from async_task_api_worker._runtime.sync_bridge import TaskCancelledError, ThreadSafeProgress
+from async_task_api_worker.protocol.envelope import InputRef
+from async_task_api_worker.protocol.json_types import ProgressPayload
+
+type _ReportProgress = Callable[[float, ProgressPayload | None], Awaitable[None]]
+
+
+@dataclass(frozen=True, slots=True)
+class TaskContext:
+    """Context of an ``async def`` handler.
+
+    ``progress`` publishes the **latest state** of the task, not an event stream: updates are throttled (at most
+    one per ``WORKER_PROGRESS_MIN_INTERVAL_S``), a newer update replaces a held one, ``fraction`` must be in
+    ``[0, 1)`` and never goes back. The terminal success or failure message is the 100%.
+    """
+
+    task_id: str
+    client_id: str | None
+    attempt: int
+    deadline: float
+    logger: logging.LoggerAdapter[logging.Logger]
+    inputs: Mapping[str, InputRef]
+    _report: _ReportProgress = field(repr=False, compare=False)
+
+    def remaining(self) -> float:
+        """Seconds left before ``deadline``, never negative."""
+        return max(0.0, self.deadline - time.monotonic())
+
+    async def progress(self, fraction: float, payload: ProgressPayload | None = None) -> None:
+        """Report progress. Never raises: an invalid or failed update is dropped and counted."""
+        await self._report(fraction, payload)
+
+
+@dataclass(frozen=True, slots=True)
+class SyncTaskContext:
+    """Context of a ``def`` handler, which runs in a worker thread. Same fields as :class:`TaskContext`."""
+
+    task_id: str
+    client_id: str | None
+    attempt: int
+    deadline: float
+    logger: logging.LoggerAdapter[logging.Logger]
+    inputs: Mapping[str, InputRef]
+    _report: ThreadSafeProgress = field(repr=False, compare=False)
+    _cancel_event: threading.Event = field(repr=False, compare=False)
+
+    def remaining(self) -> float:
+        """Seconds left before ``deadline``, never negative."""
+        return max(0.0, self.deadline - time.monotonic())
+
+    def progress(self, fraction: float, payload: ProgressPayload | None = None) -> None:
+        """Report progress from the thread, with the same rules as :meth:`TaskContext.progress`."""
+        self._report(fraction, payload)
+
+    def cancelled(self) -> bool:
+        """True once the task timed out or the worker is shutting down: long loops should stop."""
+        return self._cancel_event.is_set()
+
+    def raise_if_cancelled(self) -> None:
+        """Raise the SDK cancellation (handled by the runtime) when :meth:`cancelled` is true."""
+        if self.cancelled():
+            raise TaskCancelledError

async_task_api_worker/errors.py

@@ -0,0 +1,116 @@
+"""Error types and the stable error codes the SDK itself produces."""
+
+import re
+from collections.abc import Mapping
+from enum import StrEnum
+from types import MappingProxyType
+from typing import Final
+
+_CODE_PATTERN: Final[re.Pattern[str]] = re.compile(r"^[A-Z][A-Z0-9_]{2,63}$")
+_MIN_MESSAGE_LENGTH: Final[int] = 1
+MAX_MESSAGE_LENGTH: Final[int] = 500
+
+
+class ErrorCode(StrEnum):
+    """Codes produced by the SDK itself. They are stable and documented in the protocol spec."""
+
+    INPUT_INVALID = "INPUT_INVALID"
+    OUTPUT_INVALID = "OUTPUT_INVALID"
+    TASK_TIMEOUT = "TASK_TIMEOUT"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+    UPSTREAM_UNAVAILABLE = "UPSTREAM_UNAVAILABLE"
+    # Same value as ``CODE_ABANDON`` in ``listener/services/rebut_listener.py``.
+    TASK_ABANDONED_AFTER_REDELIVERIES = "TASK_ABANDONED_AFTER_REDELIVERIES"
+    # Raised by the ``[s3]`` and ``[llm]`` extras.
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND"
+    FILE_TOO_LARGE = "FILE_TOO_LARGE"
+    LLM_OUTPUT_INVALID = "LLM_OUTPUT_INVALID"
+    LLM_OUTPUT_TRUNCATED = "LLM_OUTPUT_TRUNCATED"
+    LLM_OUTPUT_FILTERED = "LLM_OUTPUT_FILTERED"
+    LLM_REQUEST_REJECTED = "LLM_REQUEST_REJECTED"
+
+
+# Fixed client-facing text for the codes the SDK emits itself (never derived from an exception).
+DEFAULT_PUBLIC_MESSAGES: Final[Mapping[ErrorCode, str]] = MappingProxyType(
+    {
+        ErrorCode.INPUT_INVALID: "The task input does not match the service schema.",
+        ErrorCode.OUTPUT_INVALID: "The task result does not match the service schema.",
+        ErrorCode.TASK_TIMEOUT: "The task exceeded its time limit.",
+        ErrorCode.INTERNAL_ERROR: "The worker failed unexpectedly while processing the task.",
+        ErrorCode.UPSTREAM_UNAVAILABLE: "A service the task depends on is unavailable.",
+        ErrorCode.TASK_ABANDONED_AFTER_REDELIVERIES: "The task was abandoned after several delivery attempts.",
+        ErrorCode.DOCUMENT_NOT_FOUND: "The document was not found.",
+        ErrorCode.FILE_TOO_LARGE: "The file exceeds the maximum accepted size.",
+        ErrorCode.LLM_OUTPUT_INVALID: "The language model returned an unusable answer.",
+        ErrorCode.LLM_OUTPUT_TRUNCATED: "The language model answer was truncated.",
+        ErrorCode.LLM_OUTPUT_FILTERED: "The language model answer was blocked by a content filter.",
+        ErrorCode.LLM_REQUEST_REJECTED: "The language model rejected the request.",
+    },
+)
+
+# Owned by the broker side (the rebut listener concludes tasks that expired in the queue with it): the SDK never
+# emits it, and a handler must not claim it for a task that did run.
+TASK_EXPIRED_IN_QUEUE: Final[str] = "TASK_EXPIRED_IN_QUEUE"
+
+# Codes only the runtime or the broker side may emit: a handler cannot raise a ``WorkerError`` carrying one of them.
+RESERVED_CODES: Final[frozenset[str]] = frozenset(
+    {
+        ErrorCode.INPUT_INVALID,
+        ErrorCode.OUTPUT_INVALID,
+        ErrorCode.TASK_TIMEOUT,
+        ErrorCode.INTERNAL_ERROR,
+        ErrorCode.TASK_ABANDONED_AFTER_REDELIVERIES,
+        TASK_EXPIRED_IN_QUEUE,
+    },
+)
+
+
+def validate_public_message(message: str) -> None:
+    """Raise ``ValueError`` unless ``message`` is safe to show to a client: one non-empty line, bounded length."""
+    if not _MIN_MESSAGE_LENGTH <= len(message) <= MAX_MESSAGE_LENGTH or "\n" in message or "\r" in message:
+        msg = f"Error message must be a single line of {_MIN_MESSAGE_LENGTH}..{MAX_MESSAGE_LENGTH} characters"
+        raise ValueError(msg)
+
+
+class WorkerError(Exception):
+    """A failure whose code and message are safe to show to the client.
+
+    Only these two values ever reach the wire: never build the message from ``str(cause)``.
+    """
+
+    def __init__(self, code: str, message: str) -> None:
+        if not _CODE_PATTERN.fullmatch(code):
+            msg = f"Invalid error code {code!r}: expected {_CODE_PATTERN.pattern}"
+            raise ValueError(msg)
+        if code in RESERVED_CODES:
+            msg = f"Error code {code!r} is reserved for the SDK runtime"
+            raise ValueError(msg)
+        validate_public_message(message)
+        super().__init__(code, message)
+        self.code: str = code
+        self.public_message: str = message
+
+    @property
+    def wire_text(self) -> str:
+        """The ``"<CODE>: <message>"`` text form, for clients that read the failure as a string."""
+        return f"{self.code}: {self.public_message}"
+
+
+class FatalError(WorkerError):
+    """Not worth retrying: the failure is published and the delivery acked."""
+
+
+class RetryableError(WorkerError):
+    """Transient: backoff and requeue until the broker's last delivery attempt."""
+
+
+class ProbeError(Exception):
+    """Raised by a readiness probe to signal "not ready", optionally with a safe detail."""
+
+
+class WorkerConfigurationError(Exception):
+    """Invalid settings or budget: the worker refuses to start."""
+
+
+class WorkerDefinitionError(Exception):
+    """Invalid decorator usage, raised at import time."""

async_task_api_worker/observability/__init__.py

@@ -0,0 +1 @@
+"""Probes, metrics and logs of a running worker."""