dirigent-client 0.9.0__py3-none-any.whl

dirigent_client/resources/pipelines.py

@@ -0,0 +1,209 @@
+"""Pipelines: applying a document, and everything that can be done to a stored one."""
+
+import builtins
+from collections.abc import Sequence
+from datetime import datetime
+from pathlib import Path
+from typing import cast
+
+import yaml
+
+from dirigent_client.enums import LogLevel, ProvenanceSource, RunPriority
+from dirigent_client.errors import DirigentError
+from dirigent_client.resources.base import Resource, query, request_body
+from dirigent_client.schemas import (
+    ApplyRequest,
+    ApplyResult,
+    BackfillAccepted,
+    BackfillRequest,
+    JsonMap,
+    Page,
+    PipelineDetail,
+    PipelineOut,
+    PipelineVersionOut,
+    PruneRequest,
+    PruneResult,
+    RunAccepted,
+    RunRequest,
+    ValidationIssue,
+)
+
+type DocumentSource = JsonMap | str | Path
+
+
+class Pipelines(Resource):
+    """Apply, export, activate, delete, and run the definitions an instance holds."""
+
+    async def list(
+        self, *, after: str | None = None, limit: int | None = None, tags: Sequence[str] = ()
+    ) -> Page[PipelineOut]:
+        """List every pipeline, with how many of its runs are still in flight.
+
+        Naming more than one tag narrows: a pipeline is listed only if it wears all of them.
+        """
+        return await self._many(
+            PipelineOut, "GET", "/pipelines", params=query(after=after, limit=limit, tag=[*tags] or None)
+        )
+
+    async def get(self, code: str) -> PipelineDetail:
+        """Read a pipeline and the document its current version holds."""
+        return await self._one(PipelineDetail, "GET", f"/pipelines/{code}")
+
+    async def apply(
+        self,
+        document: DocumentSource,
+        *,
+        code: str | None = None,
+        source: ProvenanceSource | None = None,
+        source_ref: str | None = None,
+        dry_run: bool = False,
+        pause_schedules: bool = False,
+    ) -> ApplyResult:
+        """Validate a document against this instance and commit a new version, or plan one.
+
+        A document this instance cannot run arrives as a 200 with ``action`` of ``invalid``
+        and the issues on the plan, not as a refusal. ``pause_schedules`` creates the
+        schedules this apply brings into being paused, and leaves existing ones alone.
+        """
+        parsed, provenance, ref = read_document(document)
+        payload = ApplyRequest(
+            document=parsed,
+            code=code,
+            source=source if source is not None else provenance,
+            source_ref=source_ref if source_ref is not None else ref,
+            pause_schedules=pause_schedules,
+        )
+        return await self._one(
+            ApplyResult,
+            "POST",
+            "/pipelines/$apply",
+            json=request_body(payload),
+            params={"dry_run": dry_run},
+        )
+
+    async def prune(self, keep: Sequence[str], *, dry_run: bool = False) -> PruneResult:
+        """Deactivate every directory-provenance pipeline whose code is not in ``keep``.
+
+        The reconcile half of a directory apply: what the directory no longer holds is
+        deactivated, never deleted, and a pipeline applied any other way is never touched.
+        """
+        payload = PruneRequest(keep=[*keep])
+        return await self._one(
+            PruneResult,
+            "POST",
+            "/pipelines/$prune",
+            json=request_body(payload),
+            params={"dry_run": dry_run},
+        )
+
+    async def versions(
+        self, code: str, *, after: str | None = None, limit: int | None = None
+    ) -> Page[PipelineVersionOut]:
+        """List every immutable version, newest first, with its provenance."""
+        return await self._many(
+            PipelineVersionOut, "GET", f"/pipelines/{code}/versions", params=query(after=after, limit=limit)
+        )
+
+    async def export(self, code: str, *, version: int | None = None) -> str:
+        """Render a stored pipeline as the canonical YAML a git repository holds."""
+        return await self._transport.text(f"/pipelines/{code}/$export", params=query(version=version))
+
+    async def validate(self, code: str, *, version: int | None = None) -> builtins.list[ValidationIssue]:
+        """Report what a stored version would fail on if it ran now, against this instance.
+
+        The issues are bounded by the document, so this one answers a bare array, not a page.
+        builtins names the type because this class has a method called ``list``.
+        """
+        rows = await self._transport.json("POST", f"/pipelines/{code}/$validate", params=query(version=version))
+        return [ValidationIssue.model_validate(row) for row in rows]
+
+    async def activate(self, code: str) -> PipelineOut:
+        """Make a pipeline runnable again, and let its schedules fire."""
+        return await self._one(PipelineOut, "POST", f"/pipelines/{code}/$activate")
+
+    async def deactivate(self, code: str) -> PipelineOut:
+        """Deregister a pipeline: schedules pause, it stops being runnable, history is kept."""
+        return await self._one(PipelineOut, "POST", f"/pipelines/{code}/$deactivate")
+
+    async def delete(self, code: str) -> None:
+        """Delete a pipeline and every run ever attributed to it, refusing while any is in flight."""
+        await self._transport.request("DELETE", f"/pipelines/{code}")
+
+    async def run(
+        self,
+        code: str,
+        *,
+        params: JsonMap | None = None,
+        window: tuple[datetime, datetime] | None = None,
+        log_levels: dict[str, LogLevel] | None = None,
+        priority: RunPriority | None = None,
+    ) -> RunAccepted:
+        """Start an ad hoc run, with parameters validated against the pipeline's own schema.
+
+        A ``run_id`` of ``None`` is not a failure: the pipeline's concurrency policy declined
+        to start a second run while one is in flight, and ``detail`` says so.
+
+        ``window`` is the logical data interval the run covers, half-open, which its document
+        reads as ``${run.window.start}`` and ``${run.window.end}``.
+
+        ``log_levels`` is which levels the run keeps, by block-id pattern; omitted keeps
+        info and up.
+
+        ``priority`` is how far ahead of other runs this one's attempts are claimed; omitted
+        takes the pipeline's own.
+        """
+        payload = RunRequest(
+            params=params or {},
+            window_start=window[0] if window else None,
+            window_end=window[1] if window else None,
+            log_levels=log_levels,
+            priority=priority,
+        )
+        return await self._one(RunAccepted, "POST", f"/pipelines/{code}/$run", json=request_body(payload))
+
+    async def backfill(
+        self,
+        code: str,
+        *,
+        schedule: str,
+        start: datetime,
+        end: datetime,
+        params: JsonMap | None = None,
+        dry_run: bool = False,
+    ) -> BackfillAccepted:
+        """Fill the windows a schedule's cadence puts inside ``[start, end)``, oldest first.
+
+        The schedule's clock is not touched: this creates the runs that interval should
+        already have had. ``dry_run`` answers with the same plan and creates nothing.
+        """
+        payload = BackfillRequest(
+            schedule=schedule,
+            from_=start,
+            to=end,
+            params=params,
+            dry_run=dry_run,
+        )
+        return await self._one(BackfillAccepted, "POST", f"/pipelines/{code}/$backfill", json=request_body(payload))
+
+
+def read_document(document: DocumentSource) -> tuple[JsonMap, ProvenanceSource, str | None]:
+    """Read a document from a mapping, a path, or its own text, and say where it came from."""
+    if isinstance(document, dict):
+        return dict(document), ProvenanceSource.API, None
+    if isinstance(document, Path):
+        return _parse(document.read_text()), ProvenanceSource.FILE, str(document)
+    path = Path(document)
+    if len(document) < 4096 and "\n" not in document and path.is_file():
+        return _parse(path.read_text()), ProvenanceSource.FILE, document
+    return _parse(document), ProvenanceSource.API, None
+
+
+def _parse(text: str) -> JsonMap:
+    """Read a document's text as YAML, which accepts its JSON form verbatim."""
+    try:
+        loaded: object = yaml.safe_load(text)
+    except yaml.YAMLError as error:
+        raise DirigentError(f"the document is not valid YAML or JSON: {error}") from error
+    if not isinstance(loaded, dict):
+        raise DirigentError(f"a document is a mapping, not {type(loaded).__name__}")
+    return cast("JsonMap", loaded)

dirigent_client/resources/runs.py

@@ -0,0 +1,257 @@
+"""Runs: reading them, acting on them, waiting for one, and following the story one tells."""
+
+import asyncio
+import time
+import uuid
+from collections.abc import AsyncIterator, Sequence
+from datetime import timedelta
+from typing import Final
+from uuid import UUID
+
+import httpx2
+
+from dirigent_client.enums import AttemptStatus, RunStatus
+from dirigent_client.errors import TransportError, WaitTimeout
+from dirigent_client.resources.base import Resource, query
+from dirigent_client.schemas import (
+    AttemptEvent,
+    AttemptOut,
+    ItemOut,
+    LogEntryOut,
+    Page,
+    RunDetail,
+    RunOut,
+    RunReport,
+)
+
+POLL_SECONDS: Final = 1.0
+POLL_MAX_SECONDS: Final = 15.0
+POLL_BACKOFF: Final = 1.5
+DEFAULT_WAIT: Final = timedelta(hours=1)
+DEFAULT_RECONNECTS: Final = 5
+RECONNECT_SECONDS: Final = 1.0
+
+
+class Runs(Resource):
+    """List, read, cancel, retry, and follow the runs an instance has executed."""
+
+    async def list(
+        self,
+        *,
+        pipeline: str | None = None,
+        status: RunStatus | None = None,
+        since: str | None = None,
+        tags: Sequence[str] = (),
+        after: str | None = None,
+        limit: int | None = None,
+    ) -> Page[RunOut]:
+        """List runs newest first, filtered by pipeline, status, tag, and how far back to look.
+
+        Naming more than one tag narrows: a run is listed only if its pipeline wears all of them.
+        """
+        return await self._many(
+            RunOut,
+            "GET",
+            "/runs",
+            params=query(
+                pipeline=pipeline,
+                status=status.value if status else None,
+                since=since,
+                tag=[*tags] or None,
+                after=after,
+                limit=limit,
+            ),
+        )
+
+    async def get(self, run_id: UUID | str) -> RunDetail:
+        """Read a run with the DAG view model, and how many items and attempts it has."""
+        return await self._one(RunDetail, "GET", f"/runs/{run_id}")
+
+    async def items(
+        self,
+        run_id: UUID | str,
+        *,
+        after: str | None = None,
+        limit: int | None = None,
+    ) -> Page[ItemOut]:
+        """List a run's fan-out items in the order they were created, which is grid order."""
+        return await self._many(ItemOut, "GET", f"/runs/{run_id}/items", params=query(after=after, limit=limit))
+
+    async def attempts(
+        self,
+        run_id: UUID | str,
+        *,
+        step: str | None = None,
+        status: AttemptStatus | None = None,
+        after: str | None = None,
+        limit: int | None = None,
+    ) -> Page[AttemptOut]:
+        """List a run's attempts in the order they were created, filtered by step and by state."""
+        return await self._many(
+            AttemptOut,
+            "GET",
+            f"/runs/{run_id}/attempts",
+            params=query(step=step, status=status.value if status else None, after=after, limit=limit),
+        )
+
+    async def cancel(self, run_id: UUID | str) -> RunOut:
+        """Stop what has not started, and tell the remote about what has."""
+        return await self._one(RunOut, "POST", f"/runs/{run_id}/$cancel")
+
+    async def retry(self, attempt_id: UUID | str, *, idempotency_key: str | None = None) -> AttemptOut:
+        """Create one manual attempt of a failed step, reading its upstream stored outputs."""
+        key = idempotency_key or str(uuid.uuid4())
+        return await self._one(AttemptOut, "POST", f"/attempts/{attempt_id}/$retry", headers={"Idempotency-Key": key})
+
+    async def logs(
+        self,
+        run_id: UUID | str,
+        *,
+        after: str | None = None,
+        limit: int | None = None,
+        step: str | None = None,
+    ) -> Page[LogEntryOut]:
+        """Read one page of a run's log entries, in write order."""
+        return await self._many(
+            LogEntryOut, "GET", f"/runs/{run_id}/$logs", params=query(after=after, limit=limit, step=step)
+        )
+
+    async def report(self, run_id: UUID | str) -> RunReport:
+        """Summarise a run: what each step amounted to, and how long the whole thing took."""
+        return await self._one(RunReport, "GET", f"/runs/{run_id}/$report")
+
+    async def wait(
+        self,
+        run_id: UUID | str,
+        *,
+        timeout: timedelta = DEFAULT_WAIT,
+        poll: float = POLL_SECONDS,
+    ) -> RunOut:
+        """Poll a run until it reaches a status nothing will move it out of."""
+        deadline = time.monotonic() + timeout.total_seconds()
+        interval = poll
+        while True:
+            run = (await self.get(run_id)).run
+            if run.terminal:
+                return run
+            if time.monotonic() + interval > deadline:
+                raise WaitTimeout(
+                    f"run {run_id} was still {run.status.value} after {timeout}",
+                    url=self._transport.endpoint(f"/runs/{run_id}"),
+                )
+            await asyncio.sleep(interval)
+            interval = min(interval * POLL_BACKOFF, POLL_MAX_SECONDS)
+
+    async def events(
+        self,
+        run_id: UUID | str,
+        *,
+        after: int = 0,
+        reconnects: int = DEFAULT_RECONNECTS,
+    ) -> AsyncIterator[AttemptEvent | LogEntryOut | RunOut]:
+        """Stream one run's story: its attempts as they move, what they log, and how it ended.
+
+        The server closes a stream two ways. ``end`` says the run settled, and the terminal
+        state is the last thing sent before it. ``expired`` says the stream reached the
+        server's wall-clock limit with the run still going; it is reopened from the last
+        entry yielded, and costs no reconnect. A stream that closes saying neither was cut,
+        and is reopened at the cost of one of ``reconnects`` -- the same budget a transport
+        failure spends, and a log entry delivered restores it in full.
+
+        Every attempt is replayed on connect, so a consumer dedupes what it has already read.
+        """
+        cursor = after
+        remaining = reconnects
+        while True:
+            ended = False
+            expired = False
+            advanced = False
+            try:
+                async with self._transport.stream(f"/runs/{run_id}/$events", params=query(after=cursor)) as response:
+                    async for event in httpx2.EventSource(response):
+                        if event.event == "end":
+                            ended = True
+                            break
+                        if event.event == "expired":
+                            expired = True
+                            break
+                        if not event.data:
+                            continue
+                        if event.event == "attempt":
+                            yield AttemptEvent.model_validate_json(event.data)
+                        elif event.event == "log":
+                            entry = LogEntryOut.model_validate_json(event.data)
+                            cursor = entry.id
+                            advanced = True
+                            yield entry
+                        elif event.event == "run":
+                            yield RunOut.model_validate_json(event.data)
+            except (TransportError, httpx2.StreamError):
+                if remaining <= 0:
+                    raise
+                remaining -= 1
+                await asyncio.sleep(RECONNECT_SECONDS)
+                continue
+            if ended:
+                return
+            if advanced:
+                remaining = reconnects
+            elif not expired:
+                if remaining <= 0:
+                    return
+                remaining -= 1
+            await asyncio.sleep(RECONNECT_SECONDS)
+
+    async def follow_logs(
+        self,
+        run_id: UUID | str,
+        *,
+        after: int = 0,
+        step: str | None = None,
+        reconnects: int = DEFAULT_RECONNECTS,
+    ) -> AsyncIterator[LogEntryOut]:
+        """Stream a run's log entries until the run settles, reopening a dropped connection.
+
+        The server closes a stream two ways. ``end`` says the run is terminal and there is
+        nothing more to read. ``expired`` says the stream reached the server's wall-clock
+        limit with the run still going; it is reopened from the last entry yielded, and
+        costs no reconnect. A stream that closes saying neither was cut, and is reopened at
+        the cost of one of ``reconnects`` -- the same budget a transport failure spends, and
+        an entry delivered restores it in full.
+        """
+        cursor = after
+        remaining = reconnects
+        while True:
+            ended = False
+            expired = False
+            advanced = False
+            try:
+                params = query(follow="sse", after=cursor, step=step)
+                async with self._transport.stream(f"/runs/{run_id}/$logs", params=params) as response:
+                    async for event in httpx2.EventSource(response):
+                        if event.event == "end":
+                            ended = True
+                            break
+                        if event.event == "expired":
+                            expired = True
+                            break
+                        if event.event == "log" and event.data:
+                            entry = LogEntryOut.model_validate_json(event.data)
+                            cursor = entry.id
+                            advanced = True
+                            yield entry
+            except (TransportError, httpx2.StreamError):
+                if remaining <= 0:
+                    raise
+                remaining -= 1
+                await asyncio.sleep(RECONNECT_SECONDS)
+                continue
+            if ended:
+                return
+            if advanced:
+                remaining = reconnects
+            elif not expired:
+                if remaining <= 0:
+                    return
+                remaining -= 1
+            await asyncio.sleep(RECONNECT_SECONDS)

dirigent_client/resources/schedules.py

@@ -0,0 +1,130 @@
+"""A pipeline's schedules: their clocks, their state, and what they have actually done."""
+
+from datetime import datetime, timedelta
+
+from dirigent_client.enums import LogLevel, RunPriority
+from dirigent_client.resources.base import Resource, query, request_body
+from dirigent_client.schemas import FiringOut, Page, ScheduleIn, ScheduleOut
+from dirigent_common import JsonMap, to_timedelta
+
+
+class Schedules(Resource):
+    """Declare, redeclare, pause, and read the schedules hanging from a pipeline."""
+
+    async def list(self, pipeline: str, *, after: str | None = None, limit: int | None = None) -> Page[ScheduleOut]:
+        """List every schedule on a pipeline, with when each one next fires."""
+        return await self._many(
+            ScheduleOut,
+            "GET",
+            f"/pipelines/{pipeline}/triggers/schedules",
+            params=query(after=after, limit=limit),
+        )
+
+    async def get(self, pipeline: str, code: str) -> ScheduleOut:
+        """Read one schedule by code."""
+        return await self._one(ScheduleOut, "GET", f"/pipelines/{pipeline}/triggers/schedules/{code}")
+
+    async def create(
+        self,
+        pipeline: str,
+        code: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        cron: str | None = None,
+        interval: timedelta | str | None = None,
+        at: datetime | None = None,
+        timezone: str = "UTC",
+        params: JsonMap | None = None,
+        connection_pins: JsonMap | None = None,
+        log_levels: dict[str, LogLevel] | None = None,
+        priority: RunPriority | None = None,
+    ) -> ScheduleOut:
+        """Declare a schedule on a pipeline and compute when it first fires."""
+        return await self._one(
+            ScheduleOut,
+            "POST",
+            f"/pipelines/{pipeline}/triggers/schedules",
+            json=_declaration(
+                code, name, description, cron, interval, at, timezone, params, connection_pins, log_levels, priority
+            ),
+        )
+
+    async def update(
+        self,
+        pipeline: str,
+        code: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        cron: str | None = None,
+        interval: timedelta | str | None = None,
+        at: datetime | None = None,
+        timezone: str = "UTC",
+        params: JsonMap | None = None,
+        connection_pins: JsonMap | None = None,
+        log_levels: dict[str, LogLevel] | None = None,
+        priority: RunPriority | None = None,
+    ) -> ScheduleOut:
+        """Change a schedule's clock or parameters, keeping whether it is paused."""
+        return await self._one(
+            ScheduleOut,
+            "PATCH",
+            f"/pipelines/{pipeline}/triggers/schedules/{code}",
+            json=_declaration(
+                code, name, description, cron, interval, at, timezone, params, connection_pins, log_levels, priority
+            ),
+        )
+
+    async def pause(self, pipeline: str, code: str) -> ScheduleOut:
+        """Stop a schedule firing, without losing it or its history."""
+        return await self._one(ScheduleOut, "POST", f"/pipelines/{pipeline}/triggers/schedules/{code}/$pause")
+
+    async def resume(self, pipeline: str, code: str) -> ScheduleOut:
+        """Start a schedule firing again, from the next slot rather than the ones it missed."""
+        return await self._one(ScheduleOut, "POST", f"/pipelines/{pipeline}/triggers/schedules/{code}/$resume")
+
+    async def delete(self, pipeline: str, code: str) -> None:
+        """Remove a schedule and its firing history."""
+        await self._transport.request("DELETE", f"/pipelines/{pipeline}/triggers/schedules/{code}")
+
+    async def firings(
+        self, pipeline: str, code: str, *, after: str | None = None, limit: int | None = None
+    ) -> Page[FiringOut]:
+        """Read what a schedule has actually done, newest first, including what it skipped."""
+        return await self._many(
+            FiringOut,
+            "GET",
+            f"/pipelines/{pipeline}/triggers/schedules/{code}/firings",
+            params=query(after=after, limit=limit),
+        )
+
+
+def _declaration(
+    code: str,
+    name: str | None,
+    description: str | None,
+    cron: str | None,
+    interval: timedelta | str | None,
+    at: datetime | None,
+    timezone: str,
+    params: JsonMap | None,
+    connection_pins: JsonMap | None,
+    log_levels: dict[str, LogLevel] | None,
+    priority: RunPriority | None,
+) -> JsonMap:
+    """Render a schedule declaration as the body the API takes."""
+    payload = ScheduleIn(
+        code=code,
+        name=name,
+        description=description,
+        cron=cron,
+        interval=to_timedelta(interval) if interval is not None else None,
+        at=at,
+        timezone=timezone,
+        params=params or {},
+        connection_pins=connection_pins or {},
+        log_levels=log_levels,
+        priority=priority,
+    )
+    return request_body(payload)

dirigent_client/resources/schemas.py

@@ -0,0 +1,45 @@
+"""Schemas: named JSON Schemas an instance holds, addressable by code and referenced by name."""
+
+from dirigent_client.resources.base import Resource, query, request_body
+from dirigent_client.schemas import Page, SchemaIn, SchemaOut, SchemaUpdate
+from dirigent_common import JsonMap
+
+
+class Schemas(Resource):
+    """Create, read, edit, and remove the JSON Schemas an instance holds."""
+
+    async def list(self, *, after: str | None = None, limit: int | None = None) -> Page[SchemaOut]:
+        """List every stored schema."""
+        return await self._many(SchemaOut, "GET", "/schemas", params=query(after=after, limit=limit))
+
+    async def get(self, code: str) -> SchemaOut:
+        """Read one schema by its code."""
+        return await self._one(SchemaOut, "GET", f"/schemas/{code}")
+
+    async def create(
+        self,
+        body: JsonMap,
+        *,
+        code: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> SchemaOut:
+        """Store a JSON Schema, taking its identity from its own keywords when none is given."""
+        payload = SchemaIn(code=code, name=name, description=description, body=body)
+        return await self._one(SchemaOut, "POST", "/schemas", json=request_body(payload))
+
+    async def update(
+        self,
+        code: str,
+        *,
+        body: JsonMap | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> SchemaOut:
+        """Replace a schema's body or its labels; the code is fixed."""
+        payload = SchemaUpdate(name=name, description=description, body=body)
+        return await self._one(SchemaOut, "PATCH", f"/schemas/{code}", json=request_body(payload))
+
+    async def delete(self, code: str) -> None:
+        """Remove a schema."""
+        await self._transport.request("DELETE", f"/schemas/{code}")

dirigent_client/resources/system.py

@@ -0,0 +1,36 @@
+"""What this instance is, whether it is well, and which nodes are picking work up."""
+
+from typing import Final
+
+from dirigent_client.resources.base import Resource, query
+from dirigent_client.schemas import Health, Page, Readiness, SystemInfo, WorkerOut
+
+HTTP_SERVICE_UNAVAILABLE: Final = 503
+
+
+class System(Resource):
+    """Describe the instance, and read the two probes a load balancer reads."""
+
+    async def info(self) -> SystemInfo:
+        """Describe the instance, and fan out over every connection's own health check."""
+        return await self._one(SystemInfo, "GET", "/system/info")
+
+    async def health(self) -> Health:
+        """Ask whether the process is alive, without touching any dependency."""
+        return await self._one(Health, "GET", "/health", prefixed=False)
+
+    async def ready(self) -> Readiness:
+        """Run every registered check and report the worst status.
+
+        An unhealthy instance answers 503 with the same report, so a caller reads
+        ``status`` rather than catching an exception.
+        """
+        return await self._one(Readiness, "GET", "/health/ready", prefixed=False, accept=(HTTP_SERVICE_UNAVAILABLE,))
+
+
+class Workers(Resource):
+    """Read the worker registry: who is alive, on what version, with which plugins."""
+
+    async def list(self, *, after: str | None = None, limit: int | None = None) -> Page[WorkerOut]:
+        """List the worker registry, flagging anything stale or running different code."""
+        return await self._many(WorkerOut, "GET", "/workers", params=query(after=after, limit=limit))