The top bar is Roles and Applications plus health's cog. Behind the cog,
/settings/{ranking,searches,companies,pulls,messages,account} share one row
of sub-tabs, an underlined row on a desktop and pills on a phone. The old
paths answer 301 with their query string.
Ranking edits the first enabled agent, or creates one, with the intent,
the weights and the gates under Advanced. The order menu on Roles reads
Newest and Best match with one enabled agent, and names them with several.
config.yaml keeps the Copenhagen starter; the other two are commented
examples in config.example.yaml.
roles.js is split into roles.js, applications.js, ranking.js and
companies.js; count, cell, debounce, the company list and the affinity
control live once in app.js. app.css gets the phone frame after health and
newsdesk: one-row bar, edge-to-edge panels, 44px targets and 16px fields on
a coarse pointer, hover only where there is one, safe areas. The app is
installable from a manifest and roledesk-coloured icons. Every lede touched
is written for the person using the app.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
137 lines
5.2 KiB
Python
137 lines
5.2 KiB
Python
"""The tasks roledesk offers, and the order a pull runs them in.
|
|
|
|
pull → extract → embed → score
|
|
|
|
newsdesk's cascade convention: a cascade is a tuple of task names, and the
|
|
final job of one task starts the next (`step` is the callback it carries).
|
|
Nothing is alive between two tasks.
|
|
|
|
Every stage is always in the chain, and a stage that is switched off finds
|
|
nothing: `extract.enabled: false`, or an `on_ingest` this pull does not
|
|
satisfy, is an extract stage with no batches whose final job moves straight
|
|
on. Extract runs before score so the gates read what it filled; before embed
|
|
too, since embedding does not read its columns and the order costs nothing.
|
|
|
|
A batch that failed, or a stage somebody killed, does not stop the chain: the
|
|
work comes round on the next pull, and a rescore of what did arrive is worth
|
|
having either way.
|
|
|
|
`pull` is a job as well as a cascade, because a schedule enqueues a job kind
|
|
and a cascade is started by one: the `pull` job's only work is to ask for the
|
|
chain. Its default schedule, `every 6h`, is declared here beside it.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable
|
|
from dataclasses import replace
|
|
from functools import partial
|
|
from typing import Any
|
|
|
|
from app.jobs import embed, extract, pull, score # noqa: F401 -- registers the jobs
|
|
from desk.tools import agent
|
|
from pipeline import NULL, TASKS, RunContext, Tally, Task, declare, job
|
|
|
|
STEP = "app.jobs.cascade:step"
|
|
|
|
CASCADES: dict[str, tuple[str, ...]] = {
|
|
"pull": ("pull", "extract", "embed", "score"),
|
|
}
|
|
|
|
|
|
def _once(config: Any, store: Any) -> list[dict[str, Any]]:
|
|
"""One batch with nothing in its payload: a task that is a single job."""
|
|
return [{}]
|
|
|
|
|
|
def _extract(cascade: str) -> Task:
|
|
"""`extract` as a stage, reading `on_ingest` when it is one of a pull.
|
|
`never`, or `auto` with no model reachable, is a stage that finds
|
|
nothing. Standing on its own, as the button, it reads neither."""
|
|
stage = extract.extract_task()
|
|
if not cascade:
|
|
return stage
|
|
find = stage.finder
|
|
|
|
def during_a_pull(config: Any, store: Any) -> list[Any]:
|
|
when = config.extract.on_ingest
|
|
if when == "never" or (when == "auto" and not agent.backend(config.agent)):
|
|
return []
|
|
return find(config, store)
|
|
|
|
return replace(stage, finder=during_a_pull)
|
|
|
|
|
|
STAGES: dict[str, Callable[[str], Task]] = {
|
|
"pull": lambda cascade: pull.pull_task(),
|
|
"extract": _extract,
|
|
"embed": lambda cascade: Task(kind="embed", finder=_once, label="Embedding roles"),
|
|
"score": lambda cascade: Task(kind="score", finder=_once,
|
|
label="Scoring roles for every agent"),
|
|
}
|
|
|
|
|
|
def task(name: str, *, cascade: str = "") -> Task:
|
|
"""One stage as a `Task`. With `cascade` its final job carries `step`,
|
|
and the next stage follows; without, it stops when its batches do."""
|
|
return replace(STAGES[name](cascade), name=name,
|
|
callback=STEP if cascade else "",
|
|
carries={"cascade": cascade, "task": name})
|
|
|
|
|
|
def follows(cascade: str, name: str) -> str:
|
|
"""What runs after `name`, or "" at the end or for an unknown name."""
|
|
tasks = CASCADES.get(cascade, ())
|
|
if name not in tasks:
|
|
return ""
|
|
at = tasks.index(name)
|
|
return tasks[at + 1] if at + 1 < len(tasks) else ""
|
|
|
|
|
|
def step(config: Any, store: Any, tally: Tally, payload: dict[str, Any], *,
|
|
context: Any) -> dict[str, Any]:
|
|
"""The callback: make the next task. A killed stage is skipped and the
|
|
chain goes on, as in newsdesk's cascade."""
|
|
name, done = payload.get("cascade", ""), payload.get("task", "")
|
|
following = follows(name, done)
|
|
if following:
|
|
context.task(task(following, cascade=name))
|
|
out: dict[str, Any] = {"task": done, "next": following}
|
|
if tally.killed:
|
|
out["skipped"] = "cancelled"
|
|
return out
|
|
|
|
|
|
def chain(name: str) -> Task:
|
|
"""The first stage of cascade `name`, carrying `step`, so the rest follow."""
|
|
return task(CASCADES[name][0], cascade=name)
|
|
|
|
|
|
@job("pull", "Pulling every board", resource="http")
|
|
def run_pull(config: Any, store: Any, *, context: RunContext = NULL) -> dict[str, Any]:
|
|
"""Ask for the pull cascade once this job is done. Its own work is nil.
|
|
|
|
Under `NULL` there is no queue to take the chain, so this raises rather
|
|
than report a pull that never happened; `app job pull` starts the chain
|
|
on a queue of its own instead of calling this.
|
|
"""
|
|
if not context.task(chain("pull")):
|
|
raise RuntimeError("no queue to start the pull cascade on")
|
|
return {"started": " > ".join(CASCADES["pull"])}
|
|
|
|
|
|
#: What `app job <name>` and the Pulls page offer besides `pull`: one stage
|
|
#: each, on its own. `pull` is not a task here, since it is a job: a name that
|
|
#: is both would be two buttons on the Pulls page.
|
|
for _name in ("extract", "embed", "score"):
|
|
TASKS[_name] = partial(task, _name)
|
|
|
|
|
|
# ---------------------------------------------------------------- schedules
|
|
|
|
# The default, next to the job it fires. A starting point rather than a
|
|
# setting: a cadence edited or switched off on the Pulls page survives
|
|
# every restart (see pipeline/schedule.py).
|
|
declare("pull", "pull", "every 6h",
|
|
label="Pull every board, then extract, embed and score")
|