django-spec-tasks 0.1.0__py3-none-any.whl

django_spec_tasks/__init__.py

@@ -0,0 +1,60 @@
+"""Run a django-service-specs spec as a background task."""
+
+import importlib
+
+from django_spec_tasks.binding.task_binding import TaskBinding
+from django_spec_tasks.types.run_state import RunState
+from django_spec_tasks.types.run_status import RunStatus
+from django_spec_tasks.types.sweep_report import SweepReport
+from django_spec_tasks.types.task_backend import TaskBackend
+from django_spec_tasks.types.terminal_states import TERMINAL_STATES
+from django_spec_tasks.version import __version__
+from django_spec_tasks.worker.run_state_for import run_state_for
+
+# Served on first attribute access rather than imported here. Each of these reaches
+# the model layer when its module is imported, and Django imports this package while
+# it is still loading apps, before a model may be imported, so a plain import of one
+# here makes the package unimportable with AppRegistryNotReady. A consumer sees the
+# same names, and their static types come from __init__.pyi.
+_LAZY_EXPORTS: dict[str, str] = {
+    "SpecRun": "django_spec_tasks.models.spec_run",
+    "enqueue": "django_spec_tasks.caller.enqueue",
+    "prune_runs": "django_spec_tasks.sweep.prune_runs",
+    "read_run": "django_spec_tasks.read.read_run",
+    "run_spec": "django_spec_tasks.worker.run_spec",
+    "state_of": "django_spec_tasks.read.state_of",
+    "sweep_runs": "django_spec_tasks.sweep.sweep_runs",
+}
+
+__all__ = [
+    "TERMINAL_STATES",
+    "RunState",
+    "RunStatus",
+    "SpecRun",
+    "SweepReport",
+    "TaskBackend",
+    "TaskBinding",
+    "__version__",
+    "enqueue",
+    "prune_runs",
+    "read_run",
+    "run_spec",
+    "run_state_for",
+    "state_of",
+    "sweep_runs",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Resolve a lazily exported name from its leaf module, and cache the result."""
+    module_path = _LAZY_EXPORTS.get(name)
+    if module_path is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(importlib.import_module(module_path), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    """List every public name, lazy ones included, so tab completion sees them."""
+    return sorted(set(globals()) | set(__all__))

django_spec_tasks/__init__.pyi

@@ -0,0 +1,33 @@
+from django_spec_tasks.binding.task_binding import TaskBinding as TaskBinding
+from django_spec_tasks.caller.enqueue import enqueue as enqueue
+from django_spec_tasks.models.spec_run import SpecRun as SpecRun
+from django_spec_tasks.read.read_run import read_run as read_run
+from django_spec_tasks.read.state_of import state_of as state_of
+from django_spec_tasks.sweep.prune_runs import prune_runs as prune_runs
+from django_spec_tasks.sweep.sweep_runs import sweep_runs as sweep_runs
+from django_spec_tasks.types.run_state import RunState as RunState
+from django_spec_tasks.types.run_status import RunStatus as RunStatus
+from django_spec_tasks.types.sweep_report import SweepReport as SweepReport
+from django_spec_tasks.types.task_backend import TaskBackend as TaskBackend
+from django_spec_tasks.types.terminal_states import TERMINAL_STATES as TERMINAL_STATES
+from django_spec_tasks.version import __version__ as __version__
+from django_spec_tasks.worker.run_spec import run_spec as run_spec
+from django_spec_tasks.worker.run_state_for import run_state_for as run_state_for
+
+__all__ = [
+    "TERMINAL_STATES",
+    "RunState",
+    "RunStatus",
+    "SpecRun",
+    "SweepReport",
+    "TaskBackend",
+    "TaskBinding",
+    "__version__",
+    "enqueue",
+    "prune_runs",
+    "read_run",
+    "run_spec",
+    "run_state_for",
+    "state_of",
+    "sweep_runs",
+]

django_spec_tasks/admin.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib import admin
+from django.db.models.constants import LOOKUP_SEP
+from django.http import HttpRequest
+
+from django_spec_tasks.models.spec_run import SpecRun
+
+_PAYLOADS = frozenset({"params", "carried", "output"})
+
+
+@admin.register(SpecRun)
+class SpecRunAdmin(admin.ModelAdmin):
+    """Runs, to look at and never to change.
+
+    Nothing here adds, changes or deletes a row, and there are no actions: an admin action
+    skips the change permission, so an action that deleted would delete for a user who
+    could not. ``params``, ``carried`` and ``output`` hold what the call was given and what
+    it returned, so they are hidden, and refused as URL lookups, since a count of results
+    would answer a guess; a project that wants them in its admin sets ``show_payloads`` on a
+    subclass. The ``traceback`` shows, because triage needs it.
+    """
+
+    show_payloads = False
+
+    list_display = (
+        "id",
+        "state",
+        "spec_name",
+        "binding",
+        "actor_pk",
+        "attempts",
+        "created_at",
+        "claimed_at",
+        "finished_at",
+    )
+    list_filter = ("state", "binding")
+    search_fields = ("spec_name", "=actor_pk")
+    ordering = ("-created_at",)
+    show_full_result_count = False
+    actions = None
+
+    def get_fields(self, request: HttpRequest, obj: Any = None) -> list[Any]:
+        names = [field.name for field in SpecRun._meta.concrete_fields]
+        return [name for name in names if self.show_payloads or name not in _PAYLOADS]
+
+    def get_readonly_fields(self, request: HttpRequest, obj: Any = None) -> list[str]:
+        return self.get_fields(request, obj)
+
+    def lookup_allowed(self, lookup: str, *args: Any, **kwargs: Any) -> bool:
+        # The rest of the signature differs across the Django versions this package supports.
+        if not self.show_payloads and lookup.split(LOOKUP_SEP)[0] in _PAYLOADS:
+            return False
+        return super().lookup_allowed(lookup, *args, **kwargs)
+
+    def has_add_permission(self, request: HttpRequest) -> bool:
+        return False
+
+    def has_change_permission(self, request: HttpRequest, obj: Any = None) -> bool:
+        return False
+
+    def has_delete_permission(self, request: HttpRequest, obj: Any = None) -> bool:
+        return False

django_spec_tasks/apps.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from importlib import import_module
+from importlib.util import find_spec
+
+from django.apps import AppConfig
+from django.core.checks import register
+from django.utils.module_loading import autodiscover_modules
+
+from django_spec_tasks.checks import check_spec_run_on_default_alias
+
+
+class DjangoSpecTasksConfig(AppConfig):
+    """Registers the check, the Celery task and every project's bindings."""
+
+    name = "django_spec_tasks"
+    verbose_name = "Spec tasks"
+
+    def ready(self) -> None:
+        register(check_spec_run_on_default_alias)
+        _register_celery_task()
+        autodiscover_modules("spec_tasks")
+
+
+def _register_celery_task() -> None:
+    """Import the Celery backend whenever ``celery`` is installed.
+
+    A Celery worker runs a message by looking its name up in its own registry, so the
+    task has to be registered by importing the module, in that worker, at startup. The
+    module imports ``celery`` at its top, so the import is gated on the optional
+    dependency being there, and asking first rather than catching ``ImportError`` keeps
+    a broken backend module from reading as an absent queue.
+    """
+    if find_spec("celery") is not None:
+        import_module("django_spec_tasks.backends.celery_backend")

django_spec_tasks/backends/__init__.py

@@ -0,0 +1 @@
+"""Where a run's code executes: one ``TaskBackend`` per queue."""

django_spec_tasks/backends/celery_backend.py

@@ -0,0 +1,41 @@
+"""The Celery backend. ``apps.py`` imports this module whenever ``celery`` is installed."""
+
+from __future__ import annotations
+
+from celery import shared_task
+
+from django_spec_tasks.worker.run_spec import run_spec
+
+
+@shared_task(name="django_spec_tasks.run_spec", ignore_result=True)
+def _run_spec(run_id: str) -> None:
+    """The task a worker runs: hand the id to the package's worker.
+
+    Defined here at the top of the module, never inside ``enqueue``: a Celery worker finds a
+    message's task by looking its name up in its own registry, so the task exists there only
+    if importing this module registered it, and ``apps.py`` does that at startup. The name
+    is spelled out because messages already on a broker carry it, and a name derived from
+    this module's path would orphan them the day the module moved.
+
+    Returns ``None`` and ignores its result: the outcome is on the run's row.
+    """
+    run_spec(run_id)
+
+
+class CeleryBackend:
+    """Hands a run to a Celery worker.
+
+    ``queue`` names the queue to send to; ``None`` leaves routing to the project's
+    ``task_routes``, keyed by the stable task name. The package sets no retry, no late
+    acknowledgement, no result backend and no schedule, each because the row already
+    answers it: a second copy of a message finds the claim taken, a lost one is asked
+    for again by the sweep, and the result is on the row.
+    """
+
+    def __init__(self, queue: str | None = None) -> None:
+        self.queue = queue
+
+    def enqueue(self, run_id: str) -> None:
+        """Send the run, with its id as Celery's ``task_id`` so a log line names the run."""
+        options = {} if self.queue is None else {"queue": self.queue}
+        _run_spec.apply_async(args=[run_id], task_id=run_id, **options)

django_spec_tasks/backends/django_tasks_backend.py

@@ -0,0 +1,45 @@
+"""The Django Tasks backend: ``django.tasks`` from 6.0, the ``django-tasks`` backport below."""
+
+from __future__ import annotations
+
+try:
+    from django.tasks import task
+except ImportError:
+    from django_tasks import task
+
+from django_spec_tasks.worker.run_spec import run_spec
+
+
+@task
+def _run_spec(run_id: str) -> None:
+    """The task body.
+
+    Decorated at the top of the module because Django Tasks finds a task again by its dotted
+    path, which has to resolve to the ``Task`` itself: a worker reading a stored result, or
+    a ``db_worker`` picking up a row, imports ``module._run_spec`` and refuses a plain
+    function there. Nested in a method it would not be importable at all. Returns ``None``,
+    since a returned frozen dataclass fails the task after the work has committed, and the
+    outcome is on the run's row.
+    """
+    run_spec(run_id)
+
+
+class DjangoTasksBackend:
+    """Hands a run to Django's Tasks framework.
+
+    Name the backend in the binding; it is never chosen by what imports. ``django.tasks``
+    imports on any Django 6, and its default backend runs a task inline on the caller's
+    thread, so choosing by availability would pick that in a project running Celery.
+
+    ``alias`` is the ``TASKS`` entry to send to, ``queue`` the queue on it; ``None`` leaves
+    the framework's default. The module's task is built against the ``default`` entry, as
+    any ``@task`` is, so ``TASKS`` needs one.
+    """
+
+    def __init__(self, alias: str = "default", queue: str | None = None) -> None:
+        self.alias = alias
+        self.queue = queue
+
+    def enqueue(self, run_id: str) -> None:
+        """Send the run to the aliased backend."""
+        _run_spec.using(backend=self.alias, queue_name=self.queue).enqueue(run_id)

django_spec_tasks/binding/__init__.py

@@ -0,0 +1 @@
+"""What a queue needs that a spec does not declare."""

django_spec_tasks/binding/task_binding.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Any, ClassVar
+
+from django_service_specs import DEFAULT_POOL_SEEDS, PoolSeeds, SpecRegistry, resolve_principal
+
+from django_spec_tasks.types.task_backend import TaskBackend
+
+
+@dataclass(frozen=True, kw_only=True, eq=False)
+class TaskBinding:
+    """A registry served as background tasks, with everything a queue needs beside it.
+
+    Collaborators are objects passed here, never dotted paths in settings. A seam
+    that takes a run is handed the ``SpecRun`` row, typed ``Any`` because nothing here
+    imports a model: that is what keeps this class importable before the app registry
+    is ready.
+
+    Constructing one registers it under its name, since a worker has only the name a
+    row recorded. Autodiscovery of each installed app's ``spec_tasks`` module is what
+    makes every binding known in a worker that imported Django.
+
+    Attributes:
+        name: Recorded on every row, so it must not change while runs are pending.
+        registry: Where enqueue and the worker find a spec by name.
+        backend: Where a run's code executes.
+        resolve_actor: Turns a row's ``actor_pk`` into the principal. Raises
+            ``PrincipalUnavailable`` for anyone who may no longer act.
+        pool_seeds: The same set at enqueue and in the worker, so the prelude's seed
+            check agrees between them.
+        lease: How long a claimed run may take. Sized to the binding's longest run: a
+            worker past it is refused at its terminal write.
+        grace: How long a ``PENDING`` row waits, from the last time a backend was asked for
+            it, before the sweep asks again. Sized to how long the queue may back up: each
+            ask past it is one more message.
+        max_attempts: How many claims an idempotent run gets before it is abandoned.
+        max_output_bytes: Past this, a run ends ``OUTPUT_TOO_LARGE``. Output is never
+            truncated.
+        can_read: ``(principal, run) -> bool``, consulted beside the run's owner.
+        progress_using: A database alias progress is written through, which is what
+            makes it visible during an ``atomic=True`` run. A second connection to the same
+            database: on any other it finds no row, and writes nothing.
+        carry: ``(actor) -> JSON mapping``, recorded on the row at enqueue and handed
+            to the call context in both processes.
+        around_run: ``(run, principal) -> context manager`` around ``dispatch`` and
+            ``present``.
+        on_finish: ``(run) -> None``, inside the transaction of the terminal write.
+    """
+
+    name: str
+    registry: SpecRegistry
+    backend: TaskBackend
+    resolve_actor: Callable[[str], Any] = resolve_principal
+    pool_seeds: PoolSeeds = DEFAULT_POOL_SEEDS
+    lease: timedelta = timedelta(hours=1)
+    grace: timedelta = timedelta(minutes=10)
+    max_attempts: int = 3
+    max_output_bytes: int = 1_048_576
+    can_read: Callable[[Any, Any], bool] | None = None
+    progress_using: str | None = None
+    carry: Callable[[Any], Mapping[str, Any]] | None = None
+    around_run: Callable[[Any, Any], AbstractContextManager[Any]] | None = None
+    on_finish: Callable[[Any], None] | None = None
+
+    # On the class rather than in a module of its own: a module holding bindings
+    # would have to import this class, and this class has to reach it to register.
+    _registered: ClassVar[dict[str, TaskBinding]] = {}
+
+    def __post_init__(self) -> None:
+        if self.name in TaskBinding._registered:
+            raise ValueError(
+                f"A TaskBinding named {self.name!r} is already registered. A row records "
+                "a binding by name, so two of one name could not be told apart."
+            )
+        TaskBinding._registered[self.name] = self
+
+    @classmethod
+    def named(cls, name: str) -> TaskBinding | None:
+        """The binding registered under ``name``, or ``None``.
+
+        A row naming no binding is a rolling deploy rather than a bug, so an unknown
+        name is an answer here and not an exception.
+        """
+        return TaskBinding._registered.get(name)
+
+    @classmethod
+    def clear_registry(cls) -> None:
+        """Forget every binding: the one way a test suite empties the registry."""
+        TaskBinding._registered.clear()

django_spec_tasks/caller/__init__.py

@@ -0,0 +1 @@
+"""The caller's half: refuse what cannot run, write the row, ask a backend on commit."""

django_spec_tasks/caller/enqueue.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator, Mapping
+from typing import Any
+
+from django.db import router, transaction
+from django_service_specs import (
+    Parameters,
+    build_call_context,
+    check_call,
+    kernel_spec,
+)
+
+from django_spec_tasks.binding.task_binding import TaskBinding
+from django_spec_tasks.models.spec_run import SpecRun
+from django_spec_tasks.models.storable_json import storable_json
+from django_spec_tasks.types.run_state import RunState
+
+
+def enqueue(
+    binding: TaskBinding,
+    spec_name: str,
+    params: Mapping[str, Any],
+    *,
+    actor: Any,
+) -> str:
+    """Record a run of ``spec_name`` and ask the binding's backend to execute it on commit.
+
+    Everything that can be refused while the caller is still on the stack is refused here,
+    and a refusal writes no row and sends nothing. What is left is decided by the worker,
+    which checks again through the kernel's ``dispatch``: a grant cannot cross a process,
+    so none is carried.
+
+    ``actor`` is required. ``None`` is the declared system run, which a spec admits or
+    refuses by its own permissions; leaving it out is a ``TypeError``, so an unauthenticated
+    call cannot become a system run by omission.
+
+    The Validator does not run here. A stock one queries, needs the row it acts on, and its
+    answer would not hold by the time a worker ran.
+
+    Returns:
+        The run's id, as a string. A backend that carries a task id is given this one.
+
+    Raises:
+        LookupError: The binding's registry holds no spec of that name.
+        TypeError: The spec takes a ``file`` parameter; ``actor`` is a principal with no
+            primary key (an anonymous user); or ``params`` or the carried values would
+            change on their way through JSON.
+        PrincipalUnavailable: ``actor`` is deactivated.
+        InvalidArguments: ``params`` do not fit the spec.
+        NotPermitted: ``actor`` fails the spec's class-level permissions.
+        ImproperlyConfigured: A parameter collides with one of the binding's pool seeds.
+    """
+    registered = binding.registry.get(spec_name)
+    if registered is None:
+        raise LookupError(f"Binding {binding.name!r} has no spec named {spec_name!r}.")
+    spec = registered.spec
+
+    for path in _file_parameters(kernel_spec(spec).parameters()):
+        raise TypeError(
+            f"Spec {spec_name!r} takes a file parameter, {path!r}, which cannot cross to a "
+            "worker. Save the upload to storage and declare a parameter holding its key."
+        )
+
+    if actor is not None and getattr(actor, "pk", None) is None:
+        raise TypeError(
+            f"actor {actor!r} has no primary key, so the worker could not load it. Pass "
+            "actor=None for a system run; an unauthenticated call is not one."
+        )
+
+    carried = dict(binding.carry(actor)) if binding.carry is not None else {}
+    _require_json_round_trip(carried, "carried value")
+
+    # The grant and the seeds the checks resolved are discarded: neither crosses a process,
+    # and the worker resolves its own.
+    check_call(
+        spec,
+        principal=actor,
+        arguments=params,
+        pool_seeds=binding.pool_seeds,
+        call_context=build_call_context("task", base={"carried": carried}),
+    )
+
+    _require_json_round_trip(params, "parameter")
+
+    alias = router.db_for_write(SpecRun)
+    run = SpecRun.objects.using(alias).create(
+        binding=binding.name,
+        spec_name=spec_name,
+        params=dict(params),
+        actor_pk=None if actor is None else str(actor.pk),
+        carried=carried,
+        state=RunState.PENDING,
+    )
+    run_id = str(run.pk)
+    # robust: a broker down at commit would otherwise raise out of this callback and cancel
+    # every later one the project registered in the same transaction, while the row already
+    # makes the lost message recoverable.
+    transaction.on_commit(lambda: binding.backend.enqueue(run_id), using=alias, robust=True)
+    return run_id
+
+
+def _file_parameters(parameters: Parameters, prefix: str = "") -> Iterator[str]:
+    """The dotted path of every ``file`` parameter, however deeply it is nested."""
+    for parameter in parameters:
+        path = f"{prefix}{parameter.name}"
+        if parameter.type == "file" or parameter.items == "file":
+            yield path
+        for nested in (parameter.items, parameter.fields):
+            if isinstance(nested, Parameters):
+                yield from _file_parameters(nested, f"{path}.")
+
+
+def _require_json_round_trip(values: Mapping[str, Any], label: str) -> None:
+    """Refuse a value that JSON would change or cannot carry, naming its key.
+
+    A queue stores JSON, and what it hands a worker is what survived: a tuple comes back a
+    list, bytes a string, an integer key a string. Django Tasks accepts some of those
+    without complaint, so a backend's own gate is not this check. ``inf``, a NUL and half a
+    surrogate pair survive the round trip and fail the write, where ``TypeError`` is promised.
+    """
+    for key, value in values.items():
+        if not isinstance(key, str):
+            raise TypeError(f"The {label} key {key!r} is not a string, and JSON keys are.")
+        try:
+            storable_json(key)
+            restored = json.loads(storable_json(value))
+        except (TypeError, ValueError) as error:
+            raise TypeError(f"The {label} {key!r} is not JSON: {error}") from error
+        if restored != value:
+            raise TypeError(
+                f"The {label} {key!r} changes on its way through JSON ({value!r} comes back "
+                f"as {restored!r}). Pass the form a JSON body would carry."
+            )

django_spec_tasks/checks.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from django.apps import AppConfig, apps
+from django.core.checks import CheckMessage, Error
+from django.db import DEFAULT_DB_ALIAS, router
+
+
+def check_spec_run_on_default_alias(
+    app_configs: Sequence[AppConfig] | None, **kwargs: Any
+) -> list[CheckMessage]:
+    """Refuse a database router sending ``SpecRun`` away from the default alias.
+
+    The kernel's ``atomic`` opens on the default alias, and a run's guarantee is that
+    the service's writes and its terminal state commit together, which needs the row in
+    that transaction. Reads count as well: a worker or a caller reading a run from a
+    replica sees a state the row has already left.
+
+    Registered with no tag, because a ``Tags.database`` check runs only when ``check``
+    is told to look at a database. It reads the model from the app registry, since
+    ``apps.py`` imports this module before a model may be imported.
+    """
+    spec_run = apps.get_model("django_spec_tasks", "SpecRun")
+    routed = {"writes": router.db_for_write(spec_run), "reads": router.db_for_read(spec_run)}
+    return [
+        Error(
+            f"A database router sends SpecRun {operation} to {alias!r}.",
+            hint=(
+                "A run's terminal state commits in the transaction the service ran in, "
+                f"which the kernel opens on {DEFAULT_DB_ALIAS!r}. Route the "
+                "django_spec_tasks app there."
+            ),
+            id="django_spec_tasks.E001",
+        )
+        for operation, alias in routed.items()
+        if alias != DEFAULT_DB_ALIAS
+    ]

django_spec_tasks/management/__init__.py

@@ -0,0 +1 @@
+"""Management commands: the sweep and retention, for a project's scheduler to call."""

django_spec_tasks/management/commands/__init__.py

@@ -0,0 +1 @@
+"""The sweep and retention commands."""

django_spec_tasks/management/commands/prune_spec_runs.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from django.core.management.base import BaseCommand, CommandError, CommandParser
+
+from django_spec_tasks.sweep.prune_runs import prune_runs
+
+
+class Command(BaseCommand):
+    help = (
+        "Delete runs that finished more than --older-than days ago. A run that is still "
+        "pending or running is never deleted."
+    )
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        # No default: how long to keep a run is the project's decision, not the package's.
+        parser.add_argument("--older-than", type=int, required=True, metavar="DAYS")
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        days: int = options["older_than"]
+        if days < 0:
+            raise CommandError("--older-than must not be negative.")
+        deleted = prune_runs(older_than=timedelta(days=days))
+        self.stdout.write(f"Deleted {deleted} {'run' if deleted == 1 else 'runs'}.")

django_spec_tasks/management/commands/sweep_spec_runs.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.core.management.base import BaseCommand, CommandParser
+
+from django_spec_tasks.sweep.sweep_runs import sweep_runs
+
+
+class Command(BaseCommand):
+    help = (
+        "Ask the backend again for runs it seems to have lost, and end the runs whose "
+        "worker did not come back. Run it on the project's own schedule."
+    )
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        parser.add_argument(
+            "--limit",
+            type=int,
+            default=1000,
+            help="The most rows one sweep looks at for one binding.",
+        )
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        report = sweep_runs(limit=options["limit"])
+        self.stdout.write(
+            f"Swept spec runs: {report.requeued} requeued, {report.abandoned} abandoned, "
+            f"{report.unavailable} spec unavailable, {report.reasked} asked again, "
+            f"{report.errors} errors."
+        )