pinecall-runtime 0.1.6__py3-none-any.whl

pinecall/gateway/api/calibration.py

@@ -0,0 +1,58 @@
+"""The calibration doors: a person labels what a judge should have said; each judge is judged."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Query
+
+from pinecall.domain.errors import NotFound
+from pinecall.evals import calibration
+from pinecall.evals.calibration import Label, Where
+from pinecall.gateway import _deps
+from pinecall.gateway._deps import EvalsKey, GatewayDep, ScopeDep
+from pinecall.log import queries
+from pinecall.tenancy.keys import check_agent
+from pinecall.wire.rest.evals import Calibration, JudgeAgreement, LabelRequest
+
+router = APIRouter()
+
+
+# The key must read the call, as a replay's does; the label is kept in the call's own world.
+@router.post("/v1/evals/calibration", status_code=204)
+async def label_call(
+    body: LabelRequest, key: EvalsKey, scope: ScopeDep, gateway: GatewayDep
+) -> None:
+    """Keep what one judge should have answered on a finished call, replacing the last label."""
+    await _deps.check_readable(gateway, _deps.Reader(acting=key, scope=scope), body.call)
+    kept = await queries.scope_of_call(gateway.connections.pool, body.call)
+    if kept is None or kept.scope is None:
+        raise NotFound(_deps.NO_SUCH_CALL.format(call=body.call))
+    check_agent(key.bearer, kept.agent)
+    where = Where(org=key.org, env=kept.scope.env, agent=kept.agent)
+    author = key.bearer.key.subject or key.bearer.key.key_id
+    label = Label(call=body.call, judge=body.judge, held=body.held, author=author, note=body.note)
+    await calibration.labelled(gateway.connections.pool, where, label)
+
+
+@router.get("/v1/evals/calibration")
+async def read_calibration(
+    key: EvalsKey, gateway: GatewayDep, agent: Annotated[str | None, Query()] = None
+) -> Calibration:
+    """Each judge's agreement with the labels on the key's world's calls, one agent's or all."""
+    if agent is not None:
+        check_agent(key.bearer, agent)
+    judged = await calibration.agreement(gateway.connections.pool, key.org, key.env, agent)
+    return Calibration(
+        judges=[
+            JudgeAgreement(
+                judge=item.judge,
+                labelled=item.labelled,
+                compared=item.compared,
+                agreed=item.agreed,
+                rate=item.rate,
+                trusted=item.trusted,
+            )
+            for item in judged
+        ],
+        labels_to_judge=calibration.LABELS_TO_JUDGE,
+        agrees_at_least=calibration.AGREES_AT_LEAST,
+    )

pinecall/gateway/api/callbacks.py

@@ -0,0 +1,105 @@
+"""Callbacks: somebody the overflow told to wait, and the org's list of them."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from pinecall.domain.errors import (
+    DeclarationRefused,
+    NotFound,
+)
+from pinecall.domain.person import THE_FLEET
+from pinecall.gateway import _deps
+from pinecall.gateway._deps import (
+    Acting,
+    CallsKey,
+    GatewayDep,
+    WorkerKey,
+)
+from pinecall.gateway._gateway import Gateway
+from pinecall.log import queries
+from pinecall.tenancy import keys
+from pinecall.wire.events import CallbackRequested
+from pinecall.wire.rest.calls import CallbackList, CallbackRequest, CallbackRow
+
+router = APIRouter()
+
+
+NOT_THIS_ORGS = "agent {agent} is not this org's"
+
+
+NAME_THE_CALL = "the fleet's key asks a call back for the call it serves: name the call"
+
+
+CALLBACK = "callback.requested"
+
+
+A_PAGE = 500
+
+
+class CallbackQuery(BaseModel):
+    """Where the org's list of callbacks continues, and whose."""
+
+    after: int = 0
+    agent: str | None = None
+
+
+# The overflow names the call it answered, and the agent must be that call's org's; an app
+# names its own org's agent.
+@router.post("/v1/callbacks", status_code=204)
+async def request_callback(body: CallbackRequest, key: WorkerKey, gateway: GatewayDep) -> None:
+    """Somebody the overflow told to wait for a call back, on the agent's log."""
+    keys.check_agent(key.bearer, body.agent)
+    owner = await gateway.logs.store.owner(body.agent)
+    fleet = THE_FLEET in key.bearer.key.scopes
+    acting_for = await _org_of_the_call(gateway, key, body.call) if fleet else key.org
+    if owner is None or owner != acting_for:
+        raise NotFound(NOT_THIS_ORGS.format(agent=body.agent))
+    wanted = CallbackRequested(
+        channel=body.channel, number=body.number, via="overflow", call=body.call, contact=None
+    )
+    await gateway.logs.agent(body.agent).append(CALLBACK, wanted.written())
+
+
+@router.get("/v1/callbacks", response_model_exclude_unset=True)
+async def list_callbacks(
+    key: CallsKey, gateway: GatewayDep, query: Annotated[CallbackQuery, Query()]
+) -> CallbackList:
+    """The org's callbacks in the key's world, oldest first, a page at a time."""
+    page = await gateway.logs.store.across([CALLBACK], after=query.after, limit=A_PAGE)
+    # An agent's log holds both worlds' callbacks: each is the world of the call it names.
+    named = [str(item.entry.data["call"]) for item in page if item.entry.data.get("call")]
+    worlds = await queries.envs_of_calls(gateway.connections.pool, named)
+    ours = [
+        item
+        for item in page
+        if item.org == key.org
+        and worlds.get(str(item.entry.data.get("call"))) == key.env
+        and (query.agent is None or item.entry.agent == query.agent)
+    ]
+    return CallbackList(
+        requests=[
+            CallbackRow.model_validate(
+                {
+                    "position": our.position,
+                    "agent": our.entry.agent,
+                    "ts": our.entry.ts,
+                    **our.entry.data,
+                }
+            )
+            for our in ours
+        ],
+        next=page[-1].position if len(page) == A_PAGE else None,
+    )
+
+
+async def _org_of_the_call(gateway: Gateway, key: Acting, call: str | None) -> str:
+    if call is None:
+        raise DeclarationRefused(NAME_THE_CALL)
+    kept = await queries.scope_of_call(gateway.connections.pool, call)
+    if kept is None or kept.scope is None:
+        raise NotFound(_deps.NEVER_OPENED.format(call=call))
+    if kept.scope.env != key.env:
+        raise NotFound(_deps.NO_SUCH_CALL.format(call=call))
+    return kept.scope.org