Serve Best CV match, Closing soon, the language flag and the deadline in the feed, and suggest an agent's languages from its CV

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Opus 5.5 committed 2026-10-03 22:04:54 +02:00
1 parent 9960799b96
commit 14076e988d
5 files changed
+313 -34

No files matched your search

+2 -2
View File
@@ -954,7 +954,7 @@ class RoleLanguage(Model):
kind: LanguageKind = "required"
def _role_languages(value: Any) -> list[RoleLanguage]:
def role_languages(value: Any) -> list[RoleLanguage]:
out = []
for item in _json_list(value):
try:
@@ -966,7 +966,7 @@ def _role_languages(value: Any) -> list[RoleLanguage]:
#: `roles.languages_required`: NULL (never read) and [] are both no language.
RoleLanguages = Annotated[list[RoleLanguage], BeforeValidator(_role_languages)]
RoleLanguages = Annotated[list[RoleLanguage], BeforeValidator(role_languages)]
LangFlag = Literal["missing", "below", "plus", ""]
+72 -21
View File
@@ -26,7 +26,7 @@ from app.models import (
AFFINITY, HAND_REASONS, LEVELS, STATUSES, Agent, Application,
ApplicationEvent, Candidate, Company, CvLanguage, Gate, Judgement, Limits, Prompt, Role,
RoleCopy, RolePlace, RoleRow, ScoredRole, cv_languages as normal_languages, cv_score,
language_flag,
language_flag, role_languages,
Subscription, Weights, check_prompts, company_fold, company_key, country_of, excerpt, place_key,
fetch_terms as normal_terms, host_word, iso_day, posted_at, posted_host, remote_of, title_key,
)
@@ -119,6 +119,18 @@ _VOTED_SCORE = ("MIN(1.0, s.score * CASE v.vote WHEN -1 THEN 0.5 "
#: nothing, so `vote` and `voted_at` are NULL: one query shape either way.
_WITH_VOTES = "LEFT JOIN role_votes v ON v.uid = roles.uid AND v.agent_id = ?"
#: The agent's `judge` readings beside every role, the same way: `j.cv_score`
#: is NULL for a role not judged and with no agent.
_WITH_JUDGEMENTS = ("LEFT JOIN role_judgements j ON j.uid = roles.uid AND j.agent_id = ? "
"AND j.judged_at IS NOT NULL")
#: The order of Best CV match: the judged roles by `cv_score`, then the rest
#: by score, as `roles` orders them.
_BY_CV = "j.cv_score IS NULL, j.cv_score DESC, "
#: How many days after today the feed's Closing soon filter reaches.
CLOSING_DAYS = 4
#: What `roles_page` reads for `RoleRow.excerpt`: the summary when there is
#: one, else the description's opening. A `SUBSTR` of the source column, not
#: the column itself, so a big `description` never leaves SQLite whole for a
@@ -867,7 +879,8 @@ class Store:
def role(self, uid: str, agent_id: int | None = None) -> ScoredRole | None:
"""One role with its tags, and with `vote`, `voted_at`, `score`,
`gated_reason` and `prompt` as `agent_id` judged and scored it; None
`gated_reason` and `prompt` as `agent_id` judged and scored it, and
its `judgement`, `cv_score` and language flag for that agent; None
(unjudged, unscored) without an agent. The score is moved by the vote
as `roles` serves it."""
row = self._row(
@@ -883,6 +896,10 @@ class Store:
role.copies = self._copies_of(uid)
role.places = self.role_places(uid)
role.remote_where = self._remote_where([uid]).get(uid, "")
role.judgement = self.judgement(agent_id, uid)
role.cv_score = role.judgement.cv_score if role.judgement else None
role.lang_flag, role.lang_note = language_flag(role.languages_required,
self._languages_of(agent_id))
return role
def _copies_of(self, uid: str) -> list[RoleCopy]:
@@ -1059,7 +1076,8 @@ class Store:
judged: str | None = None, pay: str | None = None,
company_keys: Sequence[str] = (), places: Sequence[str] = (),
seniority: Sequence[str] = (), seniority_unknown: bool = True,
pay_unknown: bool = False, offset: int = 0) -> list[ScoredRole]:
pay_unknown: bool = False, by_cv: bool = False, closing: bool = False,
offset: int = 0) -> list[ScoredRole]:
"""Newest first by `posted_at`. `company` and `place` are
case-insensitive substrings of the columns a board wrote — not the
key, so a search does not have to know the exact slug a company folds
@@ -1102,6 +1120,13 @@ class Store:
rescore. With `by_score` off the order is newest, with the votes and
no score.
With `by_cv` as well, the roles the agent's `judge` read come first
by `cv_score`, then the others by score (Best CV match). Every row
carries the agent's `cv_score` (None when not judged) and the
language flag of its languages against the agent's
(`language_flag`). `closing` keeps the roles whose `deadline` falls
today or in the next `CLOSING_DAYS` days.
`offset` skips that many rows of the same order, for the page that
loads the next 60 as it is scrolled; `count_roles` is the total.
Every returned role carries its tags, read with one extra query for
@@ -1111,13 +1136,14 @@ class Store:
remote=remote, days=days, hide_muted=hide_muted, include_read=include_read,
tags=tags, tag_mode=tag_mode, agent=agent, by_score=by_score, gated=gated,
judged=judged, pay=pay, company_keys=company_keys, places=places,
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown)
select = "SELECT roles.*, v.vote, v.voted_at"
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown,
closing=closing)
select = "SELECT roles.*, v.vote, v.voted_at, j.cv_score"
order = "roles.posted_at DESC, roles.uid"
scored = agent is not None and by_score
if scored:
select += f", {_VOTED_SCORE} AS score, s.gated_reason, s.prompt"
order = "score DESC, " + order
order = (_BY_CV if by_cv else "") + "score DESC, " + order
elif open_only:
# Newest first, open only: idx_roles_posted covers this exactly
# (posted_at DESC, uid, WHERE closed_at IS NULL), so it earns the
@@ -1131,11 +1157,18 @@ class Store:
f"{select} {sql} ORDER BY {order} LIMIT ? OFFSET ?", [*params, limit, offset])]
by_uid = self._tags_by_uid([r.uid for r in found])
areas = self._remote_where([r.uid for r in found])
mine = self._languages_of(agent)
for r in found:
r.tags = by_uid.get(r.uid, [])
r.remote_where = areas.get(r.uid, "")
r.lang_flag, r.lang_note = language_flag(r.languages_required, mine)
return found
def _languages_of(self, agent_id: int | None) -> list[CvLanguage]:
"""The languages the agent's CV states, [] with no agent."""
found = self.agent(agent_id) if agent_id is not None else None
return found.cv_languages if found else []
def roles_page(self, limit: int = 100, company: str | None = None,
place: str | None = None, open_only: bool = True,
q: str | None = None, function: str | None = None,
@@ -1146,7 +1179,8 @@ class Store:
judged: str | None = None, pay: str | None = None,
company_keys: Sequence[str] = (), places: Sequence[str] = (),
seniority: Sequence[str] = (), seniority_unknown: bool = True,
pay_unknown: bool = False, offset: int = 0) -> list[RoleRow]:
pay_unknown: bool = False, by_cv: bool = False, closing: bool = False,
offset: int = 0) -> list[RoleRow]:
"""What `GET /api/roles` serves: the same rows `roles` would, in the
same order, with the same filters and paging, but only the fields a
row draws (see `RoleRow`) — never `description`, `feed_text`, `raw`
@@ -1154,6 +1188,9 @@ class Store:
or not a page ever renders them. The reader still gets the whole role
by uid, see `role`.
`lang_flag` and `lang_note` are the role's languages against the
agent's (`language_flag`), and `cv_score` its `judge` total.
`excerpt` is `app.models.excerpt` over a `SUBSTR` of `_EXCERPT_SOURCE`
(`_EXCERPT_RAW` characters, trimmed further in Python), so the source
column itself never crosses out of SQLite for a list."""
@@ -1162,29 +1199,33 @@ class Store:
remote=remote, days=days, hide_muted=hide_muted, include_read=include_read,
tags=tags, tag_mode=tag_mode, agent=agent, by_score=by_score, gated=gated,
judged=judged, pay=pay, company_keys=company_keys, places=places,
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown)
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown,
closing=closing)
select = (
"SELECT roles.uid, roles.company_key, roles.company, roles.title, roles.place, "
"roles.country, roles.remote, roles.function, roles.seniority, roles.salary_min, "
"roles.salary_max, roles.currency, roles.salary_text, roles.original_url, "
"roles.posting_url, roles.posted_at, roles.read_at, "
"v.vote, v.voted_at, "
"roles.posting_url, roles.posted_at, roles.read_at, roles.deadline, "
"roles.languages_required, v.vote, v.voted_at, j.cv_score, "
f"SUBSTR({_EXCERPT_SOURCE}, 1, {_EXCERPT_RAW}) AS excerpt")
order = "roles.posted_at DESC, roles.uid"
scored = agent is not None and by_score
if scored:
select += f", {_VOTED_SCORE} AS score, s.gated_reason, s.prompt"
order = "score DESC, " + order
order = (_BY_CV if by_cv else "") + "score DESC, " + order
elif open_only:
# Same reasoning as `roles`: the planner otherwise sorts every
# open role before applying LIMIT.
sql = sql.replace("FROM roles ", "FROM roles INDEXED BY idx_roles_posted ", 1)
rows = self._rows(f"{select} {sql} ORDER BY {order} LIMIT ? OFFSET ?",
[*params, limit, offset])
mine = self._languages_of(agent)
found = []
for r in rows:
row = dict(r)
row["excerpt"] = excerpt(row["excerpt"])
row["lang_flag"], row["lang_note"] = language_flag(
role_languages(row.pop("languages_required")), mine)
found.append(RoleRow.from_row(row))
by_uid = self._tags_by_uid([f.uid for f in found])
copies = self._copy_counts([f.uid for f in found])
@@ -1206,14 +1247,16 @@ class Store:
gated: bool = False, judged: str | None = None,
pay: str | None = None, company_keys: Sequence[str] = (),
places: Sequence[str] = (), seniority: Sequence[str] = (),
seniority_unknown: bool = True, pay_unknown: bool = False) -> int:
seniority_unknown: bool = True, pay_unknown: bool = False,
by_cv: bool = False, closing: bool = False) -> int:
"""How many roles `roles` would list with the same filters and no limit."""
sql, params = self._roles_from(
company=company, place=place, open_only=open_only, q=q, function=function,
remote=remote, days=days, hide_muted=hide_muted, include_read=include_read,
tags=tags, tag_mode=tag_mode, agent=agent, by_score=by_score, gated=gated,
judged=judged, pay=pay, company_keys=company_keys, places=places,
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown)
seniority=seniority, seniority_unknown=seniority_unknown, pay_unknown=pay_unknown,
closing=closing)
row = self._row(f"SELECT COUNT(*) AS n {sql}", params)
return int(row["n"]) if row else 0
@@ -1227,7 +1270,8 @@ class Store:
pay: str | None = None, company_keys: Sequence[str] = (),
places: Sequence[str] = (), seniority: Sequence[str] = (),
seniority_unknown: bool = True,
pay_unknown: bool = False) -> dict[str, list[tuple[str, int]]]:
pay_unknown: bool = False, by_cv: bool = False,
closing: bool = False) -> dict[str, list[tuple[str, int]]]:
"""How many roles `roles` would list at each seniority level and each
pay state, each counted with every other filter and its own left
out, so the rail can say what a click would add. `seniority` is every
@@ -1239,7 +1283,7 @@ class Store:
"function": function, "remote": remote, "days": days, "hide_muted": hide_muted,
"include_read": include_read, "tags": tags, "tag_mode": tag_mode, "agent": agent,
"by_score": by_score, "gated": gated, "judged": judged,
"company_keys": company_keys, "places": places}
"company_keys": company_keys, "places": places, "closing": closing}
by_level, level_params = self._roles_from(
**shared, pay=pay, pay_unknown=pay_unknown)
by_pay, pay_params = self._roles_from(
@@ -1261,12 +1305,15 @@ class Store:
pay: str | None = None, company_keys: Sequence[str] = (),
places: Sequence[str] = (), seniority: Sequence[str] = (),
seniority_unknown: bool = True,
pay_unknown: bool = False) -> tuple[str, list[Any]]:
pay_unknown: bool = False,
closing: bool = False) -> tuple[str, list[Any]]:
"""The `FROM ... WHERE ...` that `roles` and `count_roles` share, with
its parameters in order. The agent's votes are always joined as `v`
(see `_WITH_VOTES`); its scores as `s` only when ordering by them. A
copy of another role (`rebuild_dupes`) is never listed: its kept role
stands for it and counts its copies."""
(see `_WITH_VOTES`) and its judgements as `j` (`_WITH_JUDGEMENTS`);
its scores as `s` only when ordering by them. A copy of another role
(`rebuild_dupes`) is never listed: its kept role stands for it and
counts its copies. `closing` keeps the roles whose deadline is
today or within `CLOSING_DAYS` after it."""
where: list[str] = ["roles.dup_of IS NULL"]
params: list[Any] = []
if company:
@@ -1312,6 +1359,10 @@ class Store:
params.append(agent)
if not include_read:
where.append("roles.read_at IS NULL")
if closing:
today = self.clock().date()
where.append("roles.deadline BETWEEN ? AND ?")
params += [today.isoformat(), (today + timedelta(days=CLOSING_DAYS)).isoformat()]
if tags:
marks = ", ".join("?" for _ in tags)
if tag_mode == "all":
@@ -1331,8 +1382,8 @@ class Store:
clause, values = _places_sql(places, self.gazetteer(), scope=self._scope(agent))
where.append(clause)
params += values
sql = f"FROM roles {_WITH_VOTES}"
joins: list[Any] = [agent]
sql = f"FROM roles {_WITH_VOTES} {_WITH_JUDGEMENTS}"
joins: list[Any] = [agent, agent]
if agent is not None and by_score:
sql += " JOIN scores s ON s.uid = roles.uid AND s.agent_id = ?"
joins.append(agent)
+60 -10
View File
@@ -16,11 +16,13 @@ from pydantic import BaseModel, Field
from app import jobs, places
from app.models import (
AFFINITY, RUNGS, TRACKS, Agent, Application, Company, FetchTerms, Gate, Limits, Prompts, Role, RoleRow,
AFFINITY, RUNGS, TRACKS, Agent, Application, Company, CvLanguage, CvLanguages, FetchTerms,
Gate, Limits, Prompts, Role, RoleRow,
HandReason, ScoredRole, Status, Subscription, Weights, company_key, levels_between,
)
from app.storage import Store
from app.web.deps import ConfigDep, StoreDep
from desk.notices import classify
from desk.tools import agent
from pipeline import Job
from pipeline.web import QueueDep
@@ -72,7 +74,7 @@ def _feed_filters(
tags: list[str] = Query(default=[]),
tag_mode: Literal["any", "all"] = "any",
agent: int | None = None,
order: Literal["score", "newest"] = "score",
order: Literal["score", "newest", "cv"] = "score",
gated: bool = False,
judged: Literal["", "liked", "unjudged", "passed"] = "",
pay: Literal["", "stated", "normalised", "stated_only"] = "",
@@ -83,13 +85,16 @@ def _feed_filters(
track: str = "",
seniority_unknown: bool = True,
pay_unknown: bool = False,
closing: bool = False,
) -> dict[str, Any]:
"""The feed's filters, as `Store.roles_page`, `count_roles` and
`role_facets` take them, read from the query of `GET /api/roles` and
`GET /api/roles/facets` alike. A place token that names nothing, a rung
outside `RUNGS` and a track outside `TRACKS` are a 422 sentence, not an
empty feed. The three seniority parameters become the levels between
them (`levels_between`), which is what the store filters on."""
them (`levels_between`), which is what the store filters on. `order=cv`
is the score order with the agent's judged roles first by `cv_score`
(`by_cv`)."""
for token in tokens:
if not places.known(token):
raise HTTPException(422, f"No place is known as {token!r}.")
@@ -110,10 +115,11 @@ def _feed_filters(
"function": function or None, "remote": remote or None, "days": days,
"hide_muted": not show_muted, "include_read": include_read, "tags": tags,
"tag_mode": tag_mode, "agent": _agent_id(store, agent),
"by_score": agent is not None and order == "score", "gated": gated,
"by_score": agent is not None and order in ("score", "cv"),
"by_cv": agent is not None and order == "cv", "gated": gated,
"judged": judged or None, "pay": pay or None, "company_keys": company_keys,
"places": tokens, "seniority": list(levels), "seniority_unknown": seniority_unknown,
"pay_unknown": pay_unknown}
"pay_unknown": pay_unknown, "closing": closing}
FeedFilters = Annotated[dict[str, Any], Depends(_feed_filters)]
@@ -145,7 +151,8 @@ def role_facets(store: StoreDep, filters: FeedFilters) -> Facets:
@router.get("/roles/{uid}")
def get_role(uid: str, store: StoreDep, agent: int | None = None) -> ScoredRole:
"""One role, open or closed, for the read page, with `agent`'s vote and
score, and the prompt that gave its fit (the default agent's when absent;
score, the prompt that gave its fit, its `judgement` against the agent's
CV and the language flag (the default agent's when absent;
None when there is no agent). `copies` lists the open copies of a kept
role (`RoleCopy`, for "Also posted"); a copy itself opens too, with
`dup_of` naming its kept role."""
@@ -224,7 +231,9 @@ def list_roles(
passed. With `order=score` (the default) the roles are the ones that
agent scored, best first, carrying `score` and `gated_reason`, a gated
one only with `gated=1`; with `order=newest` every open role, newest
first, with no score. Without `agent` the default agent's votes and
first, with no score; with `order=cv` (Best CV match) the scored roles
the agent's `judge` read come first by `cv_score`, the rest after them
by score. Without `agent` the default agent's votes and
hidden companies apply, the order is newest and there is no score; with
no agent at all, every vote is None and nothing is hidden.
@@ -233,7 +242,12 @@ def list_roles(
`tag_mode=all`, every one. `pay` keeps only roles whose `salary_state`
is stated or normalised, normalised only, or stated but not normalised
(`Store.PAY`); `pay_unknown` lets the roles that state no pay through
as well.
as well. `closing=1` keeps the roles whose `deadline` is today or in
the next four days (Closing soon).
Each row carries `deadline`, the agent's `cv_score` (None when not
judged), and `lang_flag` and `lang_note`, the posting's languages
against the agent's (`app.models.language_flag`).
`company` and `place` are substrings, kept for links from other pages.
The rail's fields are `company_keys` (repeated, exact keys) and
@@ -1189,7 +1203,10 @@ class AgentBody(BaseModel):
`intent` is the body from before an agent had prompts: without `prompts`
it is stored as one prompt named after the agent. `fetch_terms` narrow
what big boards send (`app/jobs/reach.py`); `[]` narrows nothing, and
leaving the key out keeps an existing agent's."""
leaving the key out keeps an existing agent's. `cv_text`,
`cv_languages`, `avoid_text` and `must_text` are what `judge` reads a
role against (`app/jobs/judge.py`), kept the same way when left out or
null."""
id: int | None = None
name: str = Field(min_length=1)
@@ -1199,9 +1216,40 @@ class AgentBody(BaseModel):
weights: Weights = Weights()
limits: Limits = Limits()
fetch_terms: FetchTerms | None = None
cv_text: str | None = None
cv_languages: CvLanguages | None = None
avoid_text: str | None = None
must_text: str | None = None
enabled: bool = True
class CvText(BaseModel):
cv_text: str = Field(min_length=1)
class CvLanguagesOut(BaseModel):
languages: list[CvLanguage]
@router.post("/agents/cv-languages")
def cv_languages(body: CvText, config: ConfigDep) -> CvLanguagesOut:
"""The languages a CV states, each with a level, from one model call
(`jobs.judge.suggest_languages`), for the owner to edit before saving.
Nothing is stored. 503 when no model is reachable, 502 when the call
gives no answer."""
if not body.cv_text.strip():
raise HTTPException(422, "Paste a CV first.")
if not agent.backend(config.agent):
raise HTTPException(503, "No model is reachable from here, so nothing can read the "
"languages. Set up the API key or Claude Code.")
try:
found = jobs.judge.suggest_languages(config, body.cv_text)
except agent.AgentError as exc:
raise HTTPException(502, classify(exc, backend=agent.backend(config.agent)).text) \
from exc
return CvLanguagesOut(languages=found)
@router.post("/agents")
def save_agent(body: AgentBody, store: StoreDep, queue: QueueDep) -> Agent:
"""Queues the rescore, which the page's `POST /api/score` after a save
@@ -1209,7 +1257,9 @@ def save_agent(body: AgentBody, store: StoreDep, queue: QueueDep) -> Agent:
try:
saved = store.save_agent(body.name, body.intent, body.gates, body.weights,
body.enabled, agent_id=body.id, limits=body.limits,
prompts=body.prompts, fetch_terms=body.fetch_terms)
prompts=body.prompts, fetch_terms=body.fetch_terms,
cv_text=body.cv_text, cv_languages=body.cv_languages,
avoid_text=body.avoid_text, must_text=body.must_text)
except ValueError as exc:
raise HTTPException(409, str(exc)) from exc
except KeyError:
+178
View File
@@ -0,0 +1,178 @@
"""The CV match in the feed and the API: Best CV match, Closing soon, the
new row and role fields, the agent's CV fields over `/api/agents`, and the
languages suggested from a CV. Nothing here reaches a model."""
from __future__ import annotations
import json
from collections.abc import Iterator
from datetime import UTC, datetime
from pathlib import Path
from typing import Any
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.config import Config, ServerConfig
from app.main import create_app
from app.models import CvLanguage, Prompt
from app.storage import Store
from desk.models import Item
from desk.tools import agent
from prepped import upsert
def posting(source_id: str, **raw: object) -> Item:
item = Item(source_id=source_id, location=f"https://boards.example/{source_id}",
title=f"Head of Data {source_id}", body="Lead the data team.",
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw=dict(raw))
item.source = "search"
return item
@pytest.fixture
def app(tmp_path: Path) -> FastAPI:
return create_app(Config(server=ServerConfig(host="127.0.0.1", port=0),
database=tmp_path / "roledesk.db"))
@pytest.fixture
def store(app: FastAPI) -> Store:
found: Store = app.state.store
found.clock = lambda: datetime(2026, 10, 3, 9, 0, tzinfo=UTC)
return found
@pytest.fixture
def client(app: FastAPI) -> Iterator[TestClient]:
with TestClient(app) as c:
yield c
def setup(store: Store) -> tuple[Any, dict[str, str]]:
"""Four roles scored a > b > c > d for an agent with a CV and languages;
c is judged 90 and b 60, a and d not at all; d is gated."""
owner = store.save_agent("Data", prompts=[Prompt(name="Lead", text="Head of data")],
cv_text="VP Data.",
cv_languages=[CvLanguage(language="da", level="native"),
CvLanguage(language="de", level="professional")])
uid = {}
for sid, deadline in (("a", "2026-10-03"), ("b", "2026-10-07"), ("c", "2026-10-08"),
("d", "2026-10-04")):
upsert(store, posting(sid, applicationDeadline=deadline))
uid[sid] = posting(sid).uid
store.replace_scores(owner.id, [(uid["a"], 0.9, ""), (uid["b"], 0.8, ""),
(uid["c"], 0.7, ""), (uid["d"], 0.6, "gated")])
store.set_judgement(owner.id, uid["c"], "k", 90, 90, 90, ["Leads data."], ["Small team."])
store.set_judgement(owner.id, uid["b"], "k", 60, 60, 60, ["Data."], ["Junior."])
with store.transaction() as conn:
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
[{"language": "sv", "level": "fluent", "kind": "required"}]), uid["a"]))
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
[{"language": "de", "level": "fluent", "kind": "required"}]), uid["b"]))
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
[{"language": "da", "level": "", "kind": "plus"}]), uid["c"]))
return owner, uid
def test_best_cv_match_puts_the_judged_first_by_cv_score(
client: TestClient, store: Store) -> None:
owner, uid = setup(store)
page = client.get("/api/roles", params={"agent": owner.id, "order": "cv"}).json()
assert [r["uid"] for r in page["items"]] == [uid["c"], uid["b"], uid["a"]]
assert [r["cv_score"] for r in page["items"]] == [90.0, 60.0, None]
assert page["total"] == 3
scored = client.get("/api/roles", params={"agent": owner.id}).json()["items"]
assert [r["uid"] for r in scored] == [uid["a"], uid["b"], uid["c"]]
assert scored[1]["cv_score"] == 60.0, "the total rides on every order"
assert client.get("/api/roles", params={"agent": owner.id,
"order": "best"}).status_code == 422
def test_a_row_carries_the_deadline_and_the_language_flag(
client: TestClient, store: Store) -> None:
owner, uid = setup(store)
rows = {r["uid"]: r for r in
client.get("/api/roles", params={"agent": owner.id}).json()["items"]}
assert rows[uid["a"]]["deadline"] == "2026-10-03"
assert (rows[uid["a"]]["lang_flag"], rows[uid["a"]]["lang_note"]) == \
("missing", "requires Swedish (fluent); yours: none")
assert (rows[uid["b"]]["lang_flag"], rows[uid["b"]]["lang_note"]) == \
("below", "requires German (fluent); yours: professional")
assert (rows[uid["c"]]["lang_flag"], rows[uid["c"]]["lang_note"]) == \
("plus", "Danish is a plus; yours: native")
def test_closing_soon_keeps_today_to_four_days_on(client: TestClient, store: Store) -> None:
owner, uid = setup(store)
params = {"agent": owner.id, "order": "newest", "closing": 1}
page = client.get("/api/roles", params=params).json()
assert sorted(r["uid"] for r in page["items"]) == sorted([uid["a"], uid["b"], uid["d"]])
assert page["total"] == 3
facets = client.get("/api/roles/facets", params=params).json()
assert sum(f["count"] for f in facets["pay"]) == 3
def test_the_role_carries_its_judgement_and_languages(
client: TestClient, store: Store) -> None:
owner, uid = setup(store)
role = client.get(f"/api/roles/{uid['c']}", params={"agent": owner.id}).json()
judgement = role["judgement"]
assert (judgement["skills"], judgement["cv_score"]) == (90, 90.0)
assert judgement["strengths"] == ["Leads data."] and judgement["gaps"] == ["Small team."]
assert judgement["judged_at"]
assert role["cv_score"] == 90.0 and role["lang_flag"] == "plus"
assert role["languages_required"] == [{"language": "da", "level": "", "kind": "plus"}]
assert role["deadline"] == "2026-10-08"
plain = client.get(f"/api/roles/{uid['a']}", params={"agent": owner.id}).json()
assert plain["judgement"] is None and plain["cv_score"] is None
def test_an_agent_without_languages_flags_nothing(client: TestClient, store: Store) -> None:
owner, uid = setup(store)
store.save_agent("Data", prompts=owner.prompts, agent_id=owner.id, cv_languages=[])
rows = client.get("/api/roles", params={"agent": owner.id}).json()["items"]
assert {r["lang_flag"] for r in rows} == {""}
def test_the_cv_fields_round_trip_and_are_kept_when_left_out(client: TestClient) -> None:
body = {"name": "Data", "cv_text": "VP Data.", "avoid_text": "Reporting.",
"must_text": "Permanent.",
"cv_languages": [{"language": "da", "level": "native"},
{"language": "EN", "level": "fluent"}]}
made = client.post("/api/agents", json=body).json()
assert made["cv_languages"] == [{"language": "da", "level": "native"},
{"language": "en", "level": "fluent"}]
kept = client.post("/api/agents", json={"id": made["id"], "name": "Data"}).json()
assert (kept["cv_text"], kept["avoid_text"], kept["must_text"]) == \
("VP Data.", "Reporting.", "Permanent.")
assert len(kept["cv_languages"]) == 2
nulls = client.post("/api/agents", json={"id": made["id"], "name": "Data",
"cv_text": None, "cv_languages": None}).json()
assert nulls["cv_text"] == "VP Data." and len(nulls["cv_languages"]) == 2
bad = client.post("/api/agents", json={"name": "Bad", "cv_languages": [
{"language": "da", "level": "good"}]})
assert bad.status_code == 422
def test_the_languages_of_a_cv_are_suggested_and_nothing_stored(
client: TestClient, store: Store, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(agent, "backend", lambda settings: "api")
monkeypatch.setattr(agent, "ask_json", lambda settings, **kwargs: agent.Reply(
data={"languages": [{"language": "da", "level": "native"}]}, backend="api"))
res = client.post("/api/agents/cv-languages", json={"cv_text": "Dansk modersmål."})
assert res.status_code == 200
assert res.json() == {"languages": [{"language": "da", "level": "native"}]}
assert store.agents() == []
assert client.post("/api/agents/cv-languages", json={"cv_text": " "}).status_code == 422
def fails(settings: Any, **kwargs: Any) -> agent.Reply:
raise agent.AgentError("timed out")
monkeypatch.setattr(agent, "ask_json", fails)
assert client.post("/api/agents/cv-languages", json={"cv_text": "CV"}).status_code == 502
monkeypatch.setattr(agent, "backend", lambda settings: "")
res = client.post("/api/agents/cv-languages", json={"cv_text": "CV"})
assert res.status_code == 503 and "No model is reachable" in res.json()["detail"]
+1 -1
View File
@@ -1011,7 +1011,7 @@ def test_the_newest_feed_query_uses_the_partial_posted_at_index(
assert "INDEXED BY idx_roles_posted" in captured[0]
with sqlite3.connect(store.path) as conn:
plan = " ".join(row[3] for row in
conn.execute("EXPLAIN QUERY PLAN " + captured[0], [None, 10, 0]))
conn.execute("EXPLAIN QUERY PLAN " + captured[0], [None, None, 10, 0]))
assert "USING INDEX idx_roles_posted" in plan and "TEMP B-TREE" not in plan
# open_only=False cannot use it: the index is partial on closed_at IS NULL.