Merge branch 'worktree-agent-a7e6bf7e67aa710c3'

This commit is contained in:
Wolf committed 2026-09-29 14:05:35 +02:00
commit 0ea6c10d80
18 files changed
+1038 -178

No files matched your search

+65 -54
View File
@@ -3,7 +3,7 @@
app serve [--host H] [--port P] [--reload]
app job pull|extract|embed|score [--payload JSON]
app worker [--workers http=8,cpu=1] [--until-idle]
app companies seed|add|discover|check
app companies seed|add|set-board|detach|discover|check
app searches add|list|remove
app db init
@@ -67,17 +67,26 @@ def build_parser() -> argparse.ArgumentParser:
companies = sub.add_parser("companies", help="the target company list")
companies_sub = companies.add_subparsers(dest="action", required=True)
seed = companies_sub.add_parser(
"seed", help="import seed/companies.json, subscribing to each readable board")
"seed", help="import seed/companies.json, and the boards it names for rows without one")
seed.add_argument("--path", default="seed/companies.json")
add = companies_sub.add_parser("add", help="add one company from its board")
add = companies_sub.add_parser(
"add", help="follow a company by its board, attaching or replacing an existing one's")
add.add_argument("board", help="host:slug, e.g. greenhouse:acme")
add.add_argument("name")
set_board = companies_sub.add_parser(
"set-board", help="attach a board to a company, or replace the one it has")
set_board.add_argument("key", help="the company key, e.g. trade-republic")
set_board.add_argument("board", help="host:slug, e.g. greenhouse:acme")
detach = companies_sub.add_parser(
"detach", help="stop reading a company's board and close its roles; the row stays")
detach.add_argument("key")
discover = companies_sub.add_parser(
"discover", help="find a company's board from its website; --add follows it")
discover.add_argument("name")
discover.add_argument("domain", help="its website, e.g. pleo.io")
discover.add_argument("--add", action="store_true",
help="add the company, with its board when one is readable")
help="add or update the company: its board when one is readable, "
"else the host it runs on")
companies_sub.add_parser("check", help="report boards that do not answer")
searches = sub.add_parser("searches", help="saved searches on cross-company job boards")
@@ -230,69 +239,41 @@ def run_companies(args: argparse.Namespace) -> int:
config = config_mod.load(args.config)
store = Store(config.database)
if args.action == "seed":
print(json.dumps(seed_companies(store, args.path)))
return 0
return seed_companies(store, args.path)
if args.action == "add":
return add_company(store, args.board, args.name)
if args.action == "set-board":
return set_board(store, args.key, args.board)
if args.action == "detach":
return detach_board(store, args.key)
if args.action == "discover":
return discover_company(store, args.name, args.domain, add=args.add)
return check_companies(store)
def seed_companies(store: Store, path: str) -> dict[str, int]:
"""Import `seed/companies.json`: one `companies` row per entry, and one
`ats` subscription for each entry with a readable `board`. An entry
without one is the point of the list as much as one with: a company worth
following whose careers site the app cannot read yet keeps its `ats`
host and `careers_url`, and the Companies section says so. A key that
already exists is skipped, so re-running only ever adds what is missing;
it never edits a row."""
from app.models import company_key
from plugins.ats import careers_url, is_known_target
def seed_companies(store: Store, path: str) -> int:
"""`app companies seed`: `app.jobs.sources.seed_companies`, its counts as
JSON and each entry that did not land whole on stderr."""
from app import jobs
data = json.loads(Path(path).read_text(encoding="utf-8"))
added = readable = skipped = 0
for row in data.get("companies", []):
name = row["name"]
key = row.get("key") or company_key(name)
if store.company(key) is not None:
skipped += 1
continue
board = row.get("board") or ""
if board and not is_known_target(board):
print(f"companies seed: {key}: {board!r} is not a known board; kept without it",
file=sys.stderr)
board = ""
host = board.partition(":")[0]
store.add_company(
name, key=key, domain=row.get("domain", ""),
careers_url=row.get("careers_url") or (careers_url(board) if board else ""),
ats=row.get("ats") or host, country=row.get("country", ""),
city=row.get("city", ""))
added += 1
if not board:
continue
try:
store.add_subscription("ats", board, label=name, company=name, board=host)
readable += 1
except ValueError as exc:
# The company row landed; the subscription is the only thing
# missing, and worth saying rather than losing silently.
print(f"companies seed: {key}: {exc}", file=sys.stderr)
return {"added": added, "readable": readable, "skipped": skipped,
"total": len(data.get("companies", []))}
result = jobs.sources.seed_companies(store, path)
for problem in result.pop("problems"):
print(f"companies seed: {problem}", file=sys.stderr)
print(json.dumps(result))
return 0
def discover_company(store: Store, name: str, domain: str, *, add: bool) -> int:
"""`app companies discover "Pleo" pleo.io [--add]`: what the company's
site says its board is, as JSON. With `--add`, the company is added the
way the seed adds it: with its board when one is readable, as a row the
app cannot read yet otherwise."""
site says its board is, as JSON. With `--add`, the company is added or
updated: its board attached or replaced when one is readable, else the
host and slug it runs on recorded; see `add_discovered`."""
from app import jobs
found = jobs.discover.discover(name, domain)
out: dict[str, Any] = {"name": name, "domain": domain, "board": found.board,
"ats": found.ats, "careers_url": found.careers_url,
"ats": found.ats, "ats_slug": found.ats_slug,
"careers_url": found.careers_url,
"evidence": found.evidence}
if add:
try:
@@ -306,8 +287,8 @@ def discover_company(store: Store, name: str, domain: str, *, add: bool) -> int:
def add_company(store: Store, board: str, name: str) -> int:
"""`app companies add greenhouse:acme "Acme"`: fetch the board first
and refuse if it does not answer, is not a known host, or the company
already exists. Port of seedgen's `-add`."""
and refuse if it does not answer or is not a known host. A company that
exists gets the board attached or replaced. Port of seedgen's `-add`."""
from app import jobs
from app.models import company_key
@@ -320,12 +301,42 @@ def add_company(store: Store, board: str, name: str) -> int:
return 0
def set_board(store: Store, key: str, board: str) -> int:
"""`app companies set-board trade-republic greenhouse:traderepublic`:
attach the board to an existing company or replace the one it has."""
from app import jobs
try:
sub, found, closed = jobs.sources.set_board(store, key, board)
except ValueError as exc:
print(f"companies set-board: {exc}", file=sys.stderr)
return 1
print(json.dumps({"key": key, "board": sub.target, "roles": found, "closed": closed}))
return 0
def detach_board(store: Store, key: str) -> int:
"""`app companies detach acme`: stop reading its board, close its roles."""
from app import jobs
try:
closed = jobs.sources.detach_board(store, key)
except KeyError:
print(f"companies detach: no company {key!r}", file=sys.stderr)
return 1
except ValueError as exc:
print(f"companies detach: {exc}", file=sys.stderr)
return 1
print(json.dumps({"key": key, "closed": closed}))
return 0
def check_companies(store: Store) -> int:
"""`app companies check`: every `ats` board, fetched once. Prints a
line per board that did not answer and exits 1 if any did not."""
from plugins.ats import fetch_board
subs = store.subscriptions(source="ats")
subs = [s for s in store.subscriptions(source="ats") if s.show]
dead = []
for sub in subs:
try:
+30 -14
View File
@@ -6,16 +6,20 @@ website, not from a board. This module gets from the one to the other: it
fetches the site's careers page, or the pages the home page links to as
careers, and looks for a link into one of the hosts in `HOSTS`. A readable
host (one the `ats` plugin parses) becomes a `board` target the pull can
read; any other host is recorded as `ats`, so the company is kept as one the
app cannot read yet rather than dropped.
read; any other host is recorded as `ats`, with its slug where the URL
carries one, so the company is kept as one the app cannot read yet rather
than dropped.
When no page names a host, the three hosts with a cheap per-slug endpoint
(Greenhouse, Lever, Ashby) are probed with the company's own slug, because a
site that draws its jobs from an iframe or a script leaves no link to find.
Only when no page names a host at all are the hosts with a cheap per-slug
endpoint (`_PROBES`) probed with the company's own slug, because a site that
draws its jobs from an iframe or a script leaves no link to find. A page that
names an unreadable host is the answer: a probe on a common name can hit
another tenant's board.
found = discover("Pleo", "pleo.io")
found.board # "greenhouse:pleo", or "" when nothing readable
found.ats # "greenhouse", "workday", ... or "" when unknown
found.ats_slug # the name that host knows the company by, or ""
found.careers_url # the page that named the host, or the careers page
found.evidence # the URL that named it
@@ -30,7 +34,7 @@ from __future__ import annotations
import logging
import re
from collections.abc import Callable, Iterable
from dataclasses import dataclass
from dataclasses import dataclass, replace
from urllib.parse import urljoin
import httpx
@@ -112,9 +116,10 @@ _ANCHOR = re.compile(r"<a\b[^>]*href\s*=\s*[\"']([^\"'#][^\"']*)[\"'][^>]*>(.*?)
_TAGS = re.compile(r"<[^>]+>")
#: Words a pattern's slug group can catch that name no board: the hosts'
#: own path segments, and the analytics subdomain Recruitee sites embed.
#: own path segments, the analytics subdomain Recruitee sites embed, and
#: the CDN Teamtailor sites load from (cdn.teamtailor.com).
_NOT_SLUGS = frozenset({"embed", "boards", "v1", "api", "www", "jobs", "careers", "apply",
"careers-analytics"})
"careers-analytics", "cdn"})
Found = tuple[str, str, str] # (host, slug, the URL that named it)
@@ -125,6 +130,7 @@ class Discovery:
board: str = ""
ats: str = ""
ats_slug: str = ""
careers_url: str = ""
evidence: str = ""
@@ -301,14 +307,22 @@ def _discover(name: str, site: str, client: httpx.Client, fetch: Fetch,
careers_page = ""
def first_readable(found: list[Found], page: str) -> Discovery | None:
"""The first readable board on a page. Otherwise the first host named
is remembered, with the first slug any page gives that host: a page
may name teamtailor by its CDN before it links acme.teamtailor.com."""
nonlocal unreadable
for host, slug, url in found:
if host in READABLE and slug:
return Discovery(board=f"{host}:{slug}", ats=host, careers_url=page,
evidence=url)
return Discovery(board=f"{host}:{slug}", ats=host, ats_slug=slug,
careers_url=page, evidence=url)
if unreadable is None and found:
host, slug, url = found[0]
unreadable = Discovery(ats=host, careers_url=page, evidence=url)
unreadable = Discovery(ats=host, ats_slug=slug, careers_url=page, evidence=url)
if unreadable is not None and not unreadable.ats_slug:
for host, slug, url in found:
if host == unreadable.ats and slug:
unreadable = replace(unreadable, ats_slug=slug, evidence=url)
break
return None
if home and (hit := first_readable(boards_in(home), home_url)):
@@ -333,11 +347,13 @@ def _discover(name: str, site: str, client: httpx.Client, fetch: Fetch,
if hit := first_readable(boards_in(text), final):
return hit
queue[:0] = [link for link in careers_links(text, final)[:2] if link not in seen]
# A page named a host the app cannot read: that is the answer, and a
# probe could only add another tenant's board of the same name.
if unreadable is not None:
return unreadable
for slug in slug_guesses(name, site):
for host in _PROBES:
if probe_slug(client, host, slug):
return Discovery(board=f"{host}:{slug}", ats=host,
return Discovery(board=f"{host}:{slug}", ats=host, ats_slug=slug,
careers_url=careers_page, evidence=_PROBES[host].format(slug=slug))
if unreadable is not None:
return unreadable
return Discovery(careers_url=careers_page)
+153 -33
View File
@@ -1,6 +1,8 @@
"""What a pull reads, changed by hand: add a board or a search, switch one on
or off. `app companies`, `app searches` and the settings pages all call these,
so the command line and the pages cannot disagree about what "off" means.
or off, attach, replace or detach a company's board, import the seed.
`app companies`, `app searches` and the settings pages all call these, so the
command line and the pages cannot disagree about what "off" means. Every way
a company gets a board is `set_board`.
A board or search switched off has its open roles closed at once. Nothing
else would ever close them, since only a pull that reads a target closes its
@@ -9,7 +11,9 @@ roles; switched back on, the next pull reopens every role it still lists.
from __future__ import annotations
import json
import os
from pathlib import Path
from typing import TYPE_CHECKING, Any
from app.config import Config
@@ -32,55 +36,171 @@ def set_fetch(store: Store, sub_id: int, fetch: bool) -> tuple[Subscription, int
return sub, closed
def add_board(store: Store, board: str, name: str) -> tuple[Subscription, int]:
"""Follow one company's ATS board: fetch it first, and refuse if the host
is unknown, the company exists, the board does not answer or lists
nothing. Returns the subscription and how many roles the board lists."""
def set_board(store: Store, key: str, board: str, *, name: str = "",
check: bool = True, **fields: str) -> tuple[Subscription, int | None, int]:
"""Read company `key` from `board` (`host:slug`): attach it to a company
that has none, replace the one it has, or create the company from `name`
when there is no row. The board is fetched first and refused if its host
is unknown or it does not answer; a board listing zero roles is kept, since
a company between openings is still one to follow. `check=False` skips the
fetch, for the seed, whose boards were read once when it was written.
The row's `ats` and `ats_slug` become the board's host and slug, and its
`careers_url` the board's page where it was empty or the old board's.
`fields` (domain, country, city, ...) fill only columns that are empty, so
nothing a person or the seed wrote is overwritten. Row and subscription
change in one transaction (`Store.set_company_board`), and replacing a
board closes the old one's open roles. Returns the subscription, how many
roles the board lists (None unchecked) and how many roles closed."""
from plugins.ats import careers_url, fetch_board, is_known_target
board, name = board.strip(), name.strip()
if not name:
raise ValueError("a company needs a name")
key = key.strip() or company_key(name)
if not is_known_target(board):
raise ValueError(f"{board!r} is not host:slug for a known ATS host, "
"e.g. greenhouse:acme or ashby:acme")
key = company_key(name)
if store.company(key) is not None:
raise ValueError(f"{name} is already followed")
try:
rows = fetch_board(board)
except Exception as exc:
raise ValueError(f"{board} did not answer: {exc}") from exc
if not rows:
raise ValueError(f"{board} answered but lists no roles; nothing added")
host = board.partition(":")[0]
store.add_company(name, key=key, careers_url=careers_url(board))
sub = store.add_subscription("ats", board, label=name, company=name, board=host)
return sub, len(rows)
company = store.company(key)
if company is None:
if not name:
raise ValueError(f"no company {key!r}; a new company needs a name")
if company_key(name) != key:
raise ValueError(f"{name!r} is not the company {key!r}")
rows: list[Any] | None = None
if check:
try:
rows = fetch_board(board)
except Exception as exc:
raise ValueError(f"{board} did not answer: {exc}") from exc
host, _, slug = board.partition(":")
writes: dict[str, str] = {k: v for k, v in fields.items() if v}
if company is not None:
writes = {k: v for k, v in writes.items() if not getattr(company, k)}
old = store.company_subscription(key)
if not company.careers_url or (old is not None
and company.careers_url == careers_url(old.target)):
writes["careers_url"] = careers_url(board)
else:
writes.setdefault("careers_url", careers_url(board))
writes.update(ats=host, ats_slug=slug)
_company, sub, closed = store.set_company_board(key, board, host=host, name=name,
fields=writes)
assert sub is not None
return sub, None if rows is None else len(rows), closed
def detach_board(store: Store, key: str) -> int:
"""Stop reading company `key`'s board: its open roles close and the row
stays, with its `ats` and `ats_slug`, as one the app does not read.
Returns how many roles closed. Raises KeyError for an unknown company and
ValueError for one with no board."""
if store.company(key) is None:
raise KeyError(key)
sub = store.company_subscription(key)
if sub is None or not sub.show:
raise ValueError(f"{key} has no board to detach")
_company, _sub, closed = store.set_company_board(key, "")
return closed
def add_board(store: Store, board: str, name: str) -> tuple[Subscription, int]:
"""Follow one company by its ATS board: `set_board` keyed by `name`, so
a company that exists gets the board attached or replaced. Returns the
subscription and how many roles the board lists."""
name = name.strip()
if not name:
raise ValueError("a company needs a name")
sub, roles, _closed = set_board(store, company_key(name), board, name=name)
return sub, roles or 0
def add_discovered(store: Store, name: str, domain: str,
found: Discovery) -> tuple[str, int]:
"""Follow a company from what `app.jobs.discover` found: through
`add_board` when the board is readable, else as a row with its `ats` host
and careers page, so the company is kept as one the app cannot read yet.
Returns the company key and how many roles its board lists (0 with no
board). Refuses a company that exists, as `add_board` does."""
"""Follow a company from what `app.jobs.discover` found. A readable
board goes through `set_board`, which attaches it, replaces the one the
company has, or creates the company. Otherwise the row records `ats`,
`ats_slug` and the careers page, as one the app cannot read yet; a
company that already has a board keeps it and this raises, since
discovery finding nothing readable is weaker evidence than a board that
answers. Returns the company key and how many roles its board lists (0
with no board)."""
name = name.strip()
if not name:
raise ValueError("a company needs a name")
key = company_key(name)
if found.board:
_sub, roles = add_board(store, found.board, name)
store.update_company(key, domain=domain, ats=found.ats)
return key, roles
if store.company(key) is not None:
raise ValueError(f"{name} is already followed")
store.add_company(name, key=key, domain=domain, ats=found.ats,
careers_url=found.careers_url)
_sub, roles, _closed = set_board(store, key, found.board, name=name, domain=domain)
return key, roles or 0
company = store.company(key)
if company is None:
store.add_company(name, key=key, domain=domain, ats=found.ats,
ats_slug=found.ats_slug, careers_url=found.careers_url)
return key, 0
sub = store.company_subscription(key)
if sub is not None and sub.show:
raise ValueError(f"{name} is read from {sub.target} and discovery found no "
"readable board; nothing changed")
store.update_company(key, ats=found.ats, ats_slug=found.ats_slug,
careers_url=found.careers_url or company.careers_url,
**({"domain": domain} if not company.domain else {}))
return key, 0
def seed_companies(store: Store, path: str | Path) -> dict[str, Any]:
"""Import `seed/companies.json`: one `companies` row per entry, and its
`board` through `set_board` where the entry names one. An entry without
a board is the point of the list as much as one with: a company whose
careers site the app cannot read yet keeps its `ats` host, `ats_slug`
and `careers_url`, and the Companies section says so.
Re-running adds what is missing: a new entry becomes a row, and an
existing row that never had a board gets the one the seed now names, so a
seed update that gains boards reaches a database made before it. A row's
board, once it has one (detached counts), and its affinity, notes and
status are never touched. The seed's boards are not fetched again: they
were read once when the seed was written, and `app companies check`
finds the dead ones. Returns counts, and `problems`, one line per entry
that could not land whole."""
from plugins.ats import is_known_target
data = json.loads(Path(path).read_text(encoding="utf-8"))
entries = data.get("companies", [])
added = boards = skipped = 0
problems: list[str] = []
for row in entries:
name = row["name"].strip()
key = row.get("key") or company_key(name)
board = (row.get("board") or "").strip()
if board and not is_known_target(board):
problems.append(f"{key}: {board!r} is not a known board; kept without it")
board = ""
facts = {f: str(row.get(f) or "") for f in ("domain", "country", "city",
"careers_url", "ats", "ats_slug")}
exists = store.company(key) is not None
if exists and (not board or store.company_subscription(key) is not None):
skipped += 1
continue
if board:
try:
set_board(store, key, board, name=name, check=False,
**{f: v for f, v in facts.items() if f not in ("ats", "ats_slug")})
boards += 1
added += not exists
continue
except ValueError as exc:
problems.append(f"{key}: {exc}")
if exists:
skipped += 1
continue
# No board, or one that clashed: the company is still a row, and a
# clashing board's host and slug are what discovery found.
if board:
facts["ats"], _, facts["ats_slug"] = board.partition(":")
store.add_company(name, key=key, **facts)
added += 1
return {"added": added, "boards": boards, "skipped": skipped, "total": len(entries),
"problems": problems}
def search_params(provider: str, q: str, *, area: int = 0, country: str = "",
where: str = "", pages: int = 0) -> dict[str, Any]:
"""The `params` a search subscription stores, with only the keys its
+3
View File
@@ -335,6 +335,9 @@ class Company(Model):
ats: str = ""
country: str = ""
city: str = ""
#: The name `ats` knows the company by, the `acme` of acme.teamtailor.com;
#: "" where discovery found none. Kept for a host no parser reads yet.
ats_slug: str = ""
created_at: str
updated_at: str
+13 -1
View File
@@ -1200,6 +1200,17 @@ table.applications td[data-label="Saved"] { white-space: nowrap; color: var(--di
gap: .4rem; font-size: .8rem; color: var(--dim);
}
.srow[data-muted="true"], .crow[data-hidden="true"] { opacity: .6; }
/* A company row's Set board / Change editor: its own line under `.sub`,
wrapping like `.sub` does, the boxes styled as `.source-form`'s. */
.crow .board-edit {
grid-column: 1 / -1; display: flex; flex-wrap: wrap; align-items: center;
gap: .4rem; padding-top: .25rem;
}
.crow .board-edit select, .crow .board-edit input {
background: var(--bg); border: 1px solid var(--line);
border-radius: .3rem; padding: .35rem .5rem;
}
.crow .board-edit input { flex: 1 1 8rem; min-width: 0; }
.linky {
padding: 0; border: 0; background: none; font-size: .8rem;
@@ -1282,7 +1293,8 @@ table.list select { padding: .25rem .4rem; }
button, .top nav a { min-height: 2.75rem; }
.top nav a { display: inline-flex; align-items: center; justify-content: center; }
.filters input[type="search"], .filters input[type="text"], .filters select,
.agent-form input, .source-form select { min-height: 2.75rem; }
.agent-form input, .source-form select,
.crow .board-edit input, .crow .board-edit select { min-height: 2.75rem; }
.affinity button { min-width: 2.75rem; }
.check input { width: 1.25rem; height: 1.25rem; }
}
+102 -7
View File
@@ -11,6 +11,12 @@
* server's default, the enabled agent with the lowest id; with no agent at
* all there is nothing to like, and the section says so instead of drawing
* the buttons.
*
* Each row's "Set board" (no board yet) or "Change" (a board) opens a small
* editor in the row: the host select, with the options the server rendered
* into the Follow form's `#b-host`, and a slug. Saving posts to
* `/api/companies/{key}/board`, which reads the board once before keeping
* it; Detach stops reading it and keeps the company.
*/
(function () {
"use strict";
@@ -21,6 +27,9 @@
/** @type {object[]} the search agents, by id */
let agents = [];
/** The key of the row whose board editor is open, or null. One at a time. */
let editing = null;
/** The id in `#c-agent`, or null while there is no agent to pick. */
function agentId() {
const value = $("#c-agent").value;
@@ -45,7 +54,7 @@
// ---------------------------------------------------------------- the list
function subLine(company) {
function subLine(company, rerender) {
const sub = document.createElement("span");
sub.className = "sub";
if (company.board) {
@@ -57,11 +66,15 @@
// Followed, but its careers site runs on nothing the app reads yet.
const badge = document.createElement("span");
badge.className = "badge";
badge.textContent = company.ats || "own site";
badge.textContent = company.ats
? (company.ats_slug ? `${company.ats}:${company.ats_slug}` : company.ats)
: "own site";
sub.appendChild(badge);
sub.append(" · not readable yet");
} else {
sub.append("from job boards");
// Every row comes from the seed, Follow or discover: none of them
// found where this company posts its roles.
sub.append("board not found");
}
if (company.careers_url && !company.board) {
const link = document.createElement("a");
@@ -72,11 +85,92 @@
sub.append(" · ");
sub.appendChild(link);
}
sub.append(` · ${count(company.open_roles, "open role")}`);
sub.append(` · ${count(company.open_roles, "open role")} `);
const edit = document.createElement("button");
edit.type = "button";
edit.className = "linky";
edit.textContent = company.subscription_id == null ? "Set board" : "Change";
edit.setAttribute("aria-expanded", String(editing === company.key));
edit.addEventListener("click", () => {
editing = editing === company.key ? null : company.key;
rerender();
});
sub.appendChild(edit);
return sub;
}
/** The board switch, or nothing for a company known only from a search:
/** The open row's board editor: host and slug, Save, Cancel, and Detach
for a row that has a board. */
function boardEditor(company, rerender) {
const form = document.createElement("form");
form.className = "board-edit";
form.autocomplete = "off";
const host = document.createElement("select");
host.setAttribute("aria-label", `${company.name}'s board host`);
for (const option of $("#b-host").options) host.appendChild(option.cloneNode(true));
const known = [...host.options].map((o) => o.value);
const current = company.board || company.ats;
if (known.includes(current)) host.value = current;
const slug = document.createElement("input");
slug.type = "text";
slug.required = true;
slug.spellcheck = false;
slug.placeholder = "slug";
slug.value = company.ats_slug || "";
slug.setAttribute("aria-label", `${company.name}'s slug on that host`);
const save = document.createElement("button");
save.type = "submit";
save.textContent = company.subscription_id == null ? "Set board" : "Change board";
const cancel = document.createElement("button");
cancel.type = "button";
cancel.className = "linky";
cancel.textContent = "Cancel";
cancel.addEventListener("click", () => { editing = null; rerender(); });
form.append(host, slug, save, cancel);
async function done() {
editing = null;
await loadCompanies(agentId());
rerender();
}
form.addEventListener("submit", async (event) => {
event.preventDefault();
save.disabled = true;
try {
const result = await api(`/api/companies/${encodeURIComponent(company.key)}/board`,
{ method: "POST", body: { board: `${host.value}:${slug.value.trim()}` } });
const closed = result.closed ? `, ${count(result.closed, "old role")} closed` : "";
window.toast.info(`${company.name}: reading ${result.source.target}, `
+ `${count(result.found, "role")} listed${closed}.`);
await done();
} catch (err) {
save.disabled = false;
}
});
if (company.subscription_id != null) {
const detach = document.createElement("button");
detach.type = "button";
detach.className = "linky";
detach.textContent = "Detach";
detach.addEventListener("click", async () => {
detach.disabled = true;
try {
const result = await api(`/api/companies/${encodeURIComponent(company.key)}/board`,
{ method: "DELETE" });
window.toast.info(`${company.name}: board detached, `
+ `${count(result.closed, "open role")} closed.`);
await done();
} catch (err) {
detach.disabled = false;
}
});
form.append(detach);
}
return form;
}
/** The board switch, or nothing for a company with no board:
there is no subscription to switch. */
function onSwitch(company, rerender) {
if (company.subscription_id == null) return null;
@@ -109,7 +203,7 @@
case "hidden": return company.affinity === -1;
case "on": return company.on === true;
case "off": return company.on === false;
case "unreadable": return company.subscription_id == null && Boolean(company.ats || company.careers_url);
case "unreadable": return company.subscription_id == null;
default: return true;
}
}
@@ -140,7 +234,8 @@
if (agent != null) {
row.appendChild(affinityControl(company.key, company.affinity, async () => render(), agent));
}
row.appendChild(subLine(company));
row.appendChild(subLine(company, render));
if (editing === company.key) row.appendChild(boardEditor(company, render));
body.appendChild(row);
}
const open = rows.reduce((sum, c) => sum + c.open_roles, 0);
+8 -2
View File
@@ -94,7 +94,9 @@ CREATE TABLE IF NOT EXISTS role_tags (
-- ats is the host the careers site runs on, readable by the ats plugin or
-- not (workday, successfactors, ...): what discovery found, '' unknown. A
-- company with an ats and no board subscription is one the app cannot read
-- yet. country is an ISO code and city the head office's.
-- yet. country is an ISO code and city the head office's. ats_slug is the
-- name that host knows the company by (the acme of acme.teamtailor.com),
-- '' where its URL carries none, kept for the parser written later.
CREATE TABLE IF NOT EXISTS companies (
key TEXT PRIMARY KEY,
name TEXT NOT NULL,
@@ -106,7 +108,8 @@ CREATE TABLE IF NOT EXISTS companies (
updated_at TEXT NOT NULL,
ats TEXT NOT NULL DEFAULT '',
country TEXT NOT NULL DEFAULT '',
city TEXT NOT NULL DEFAULT ''
city TEXT NOT NULL DEFAULT '',
ats_slug TEXT NOT NULL DEFAULT ''
);
-- The targets desk's runner hands to plugins. newsdesk's shape, with its two
@@ -337,6 +340,9 @@ ALTER TABLE companies ADD COLUMN city TEXT NOT NULL DEFAULT '';
"""),
(8, "agents.limits: how deep into its ranking the model stages read is each agent's own", """
ALTER TABLE agents ADD COLUMN limits TEXT NOT NULL DEFAULT '{}';
"""),
(9, "companies.ats_slug: the slug of a host the app cannot read yet is kept", """
ALTER TABLE companies ADD COLUMN ats_slug TEXT NOT NULL DEFAULT '';
"""),
)
+103 -14
View File
@@ -69,7 +69,8 @@ _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 = ?"
_COMPANY_FIELDS = ("name", "domain", "status", "careers_url", "notes", "ats", "country", "city")
_COMPANY_FIELDS = ("name", "domain", "status", "careers_url", "notes", "ats", "country", "city",
"ats_slug")
#: A company as the store serves it: the row and the asked-for agent's affinity.
_COMPANY_SELECT = """SELECT c.*, COALESCE(ac.affinity, 0) AS affinity FROM companies c
@@ -979,24 +980,31 @@ class Store:
def add_company(self, name: str, *, key: str = "", domain: str = "",
status: str = "researching", careers_url: str = "",
notes: str = "", ats: str = "", country: str = "",
city: str = "") -> Company:
city: str = "", ats_slug: str = "") -> Company:
"""Raises ValueError on a key already taken."""
name = name.strip()
key = key or company_key(name)
if not key:
raise ValueError("a company needs a name")
stamp = self.now()
try:
self._write(
"""INSERT INTO companies (key, name, domain, status, careers_url, notes,
ats, country, city, created_at, updated_at)
VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
(key, name, domain, status, careers_url, notes, ats, country, city,
stamp, stamp))
with self.transaction() as conn:
self._insert_company(conn, key, name, {
"domain": domain, "status": status, "careers_url": careers_url,
"notes": notes, "ats": ats, "country": country, "city": city,
"ats_slug": ats_slug})
except sqlite3.IntegrityError as exc:
raise ValueError(f"company {key!r} already exists") from exc
return self._company(key)
def _insert_company(self, conn: sqlite3.Connection, key: str, name: str,
fields: dict[str, Any]) -> None:
stamp = self.now()
columns = ["key", "name", *fields, "created_at", "updated_at"]
conn.execute(
f"INSERT INTO companies ({', '.join(columns)}) "
f"VALUES ({', '.join('?' * len(columns))})",
(key, name, *fields.values(), stamp, stamp))
def company(self, key: str, agent_id: int | None = None) -> Company | None:
"""One company, with `affinity` as `agent_id` set it; 0 without an agent."""
row = self._row(f"{_COMPANY_SELECT} WHERE c.key=?", (agent_id, key))
@@ -1029,8 +1037,8 @@ class Store:
return self._company(key, agent_id)
def update_company(self, key: str, **fields: Any) -> Company:
"""Change any of name, domain, status, careers_url, notes. Affinity is
per agent: `set_affinity`."""
"""Change any of `_COMPANY_FIELDS`. Affinity is per agent:
`set_affinity`."""
unknown = set(fields) - set(_COMPANY_FIELDS)
if unknown:
raise ValueError(f"not a company field: {', '.join(sorted(unknown))}")
@@ -1072,13 +1080,94 @@ class Store:
"""`company_key -> ats host`, read off each company's own
subscription. `Subscription.company` is the display name it and the
company row were both added with, so `company_key` of one finds the
other; a company added by hand with no subscription is simply
absent."""
other; a company with no subscription, or a detached one (`show` 0,
see `set_company_board`), is simply absent."""
boards: dict[str, str] = {}
for sub in self.subscriptions(source="ats"):
boards.setdefault(company_key(sub.company), sub.board)
if sub.show:
boards.setdefault(company_key(sub.company), sub.board)
return boards
def company_subscription(self, key: str) -> Subscription | None:
"""Company `key`'s own `ats` subscription, detached or not; None when
it never had one. A company has at most one: `set_company_board`
rewrites it in place rather than adding a second."""
with closing(self._connect()) as conn:
return self._company_subscription(conn, key)
@staticmethod
def _company_subscription(conn: sqlite3.Connection, key: str) -> Subscription | None:
rows = conn.execute("SELECT * FROM subscriptions WHERE source = 'ats' "
"ORDER BY show DESC, id").fetchall()
return next((Subscription.from_row(r) for r in rows
if company_key(r["company"]) == key), None)
def set_company_board(self, key: str, target: str, *, host: str = "", name: str = "",
fields: dict[str, Any] | None = None,
) -> tuple[Company, Subscription | None, int]:
"""Point company `key` at the `ats` board `target`, or at none when
`target` is "", in one transaction, so a clash on either table leaves
nothing half written.
A missing company is created from `name` and `fields`; an existing one
has `fields` written over it. Its subscription is rewritten in place:
a new target closes the old target's open roles, as switching a board
off does, and "" detaches it (off, hidden, its roles closed) while the
row stays for the next board. Returns the company, its subscription
(None when there is none) and how many roles closed. Raises KeyError
for a missing company with no board, ValueError on a UNIQUE clash."""
fields = dict(fields or {})
unknown = set(fields) - set(_COMPANY_FIELDS)
if unknown:
raise ValueError(f"not a company field: {', '.join(sorted(unknown))}")
stamp = self.now()
closed = 0
try:
with self.transaction() as conn:
row = conn.execute("SELECT name FROM companies WHERE key=?", (key,)).fetchone()
if row is None:
name = fields.pop("name", "") or name.strip()
if not target:
raise KeyError(key)
if not name:
raise ValueError("a company needs a name")
self._insert_company(conn, key, name, fields)
else:
name = fields.get("name") or row["name"]
if fields:
sets = ", ".join(f"{f}=?" for f in fields)
conn.execute(f"UPDATE companies SET {sets}, updated_at=? WHERE key=?",
(*fields.values(), stamp, key))
sub = self._company_subscription(conn, key)
sub_id = sub.id if sub else None
if sub is not None and sub.target != target:
closed = conn.execute(
"UPDATE roles SET closed_at = ? "
"WHERE subscription_id = ? AND closed_at IS NULL",
(stamp, sub.id)).rowcount
if not target:
if sub is not None:
conn.execute("UPDATE subscriptions SET subscribed=0, fetch=0, show=0 "
"WHERE id=?", (sub.id,))
elif sub is not None:
conn.execute(
"""UPDATE subscriptions
SET target=?, board=?, label=?, company=?, subscribed=1,
fetch=1, show=1,
target_id=CASE WHEN target=? THEN target_id ELSE '' END
WHERE id=?""",
(target, host, name, name, target, sub.id))
else:
sub_id = conn.execute(
"""INSERT INTO subscriptions (source, target, label, company, board,
params, added_at)
VALUES ('ats',?,?,?,?,'{}',?)""",
(target, name, name, host, stamp)).lastrowid
except sqlite3.IntegrityError as exc:
raise ValueError(f"another board already has {target!r} or the label "
f"{name!r}") from exc
return (self._company(key), self.subscription(sub_id) if sub_id else None, closed)
# -------------------------------------------------------- subscriptions
def subscriptions(self, source: str | None = None,
+4 -7
View File
@@ -68,14 +68,11 @@
<h3>Follow a company</h3>
<div class="form-row">
<label>Host
{# The hosts plugins.ats reads (HOST_OPTIONS in app/web/pages.py).
companies.js copies these options into each row's Set board
control, so the page has one list of hosts. #}
<select id="b-host">
<option value="greenhouse">Greenhouse</option>
<option value="lever">Lever</option>
<option value="ashby">Ashby</option>
<option value="workable">Workable</option>
<option value="smartrecruiters">SmartRecruiters</option>
<option value="recruitee">Recruitee</option>
<option value="personio">Personio</option>
{% for value, label in hosts %}<option value="{{ value }}">{{ label }}</option>{% endfor %}
</select></label>
<label>Slug
<input type="text" id="b-slug" required placeholder="acme" spellcheck="false">
+48 -10
View File
@@ -260,11 +260,12 @@ def summarise_role(uid: str, store: StoreDep, config: ConfigDep, queue: QueueDep
class CompanyOut(BaseModel):
"""A company row plus what only the store can join in: the ats host it is
read from (empty for a company known only from a search), the id of that
read from (empty for one with no board), the id of that
board's subscription, whether it is on, and how many of its roles are
still open. `ats` is the host its careers site runs on whether or not the
app reads it, so a followed company with no `board` and an `ats` is one
the app cannot read yet; `careers_url` is where a person can."""
app reads it, and `ats_slug` its name there, so a followed company with
no `board` and an `ats` is one the app cannot read yet; `careers_url` is
where a person can."""
key: str
name: str
@@ -274,6 +275,7 @@ class CompanyOut(BaseModel):
affinity: int
open_roles: int
ats: str = ""
ats_slug: str = ""
careers_url: str = ""
country: str = ""
@@ -282,9 +284,12 @@ def _company_boards(store: Store) -> dict[str, tuple[int, str, bool]]:
"""`company_key -> (subscription id, ats host, on)`, read off each
company's own subscription. Same join as `Store.company_boards`, with the
id and switch state a company row needs to draw its own on/off control
rather than fetching `/api/sources` as well."""
rather than fetching `/api/sources` as well. A detached board (`show`
0) is no board."""
boards: dict[str, tuple[int, str, bool]] = {}
for sub in store.subscriptions(source="ats"):
if not sub.show:
continue
boards.setdefault(company_key(sub.company), (sub.id, sub.board,
bool(sub.subscribed and sub.fetch)))
return boards
@@ -302,10 +307,41 @@ def list_companies(store: StoreDep, agent: int | None = None) -> list[CompanyOut
out.append(CompanyOut(key=c.key, name=c.name, board=host,
subscription_id=sub_id, on=on, affinity=c.affinity,
open_roles=counts.get(c.key, 0), ats=c.ats,
careers_url=c.careers_url, country=c.country))
ats_slug=c.ats_slug, careers_url=c.careers_url,
country=c.country))
return out
class CompanyBoardBody(BaseModel):
board: str
@router.post("/companies/{key}/board")
def set_company_board(key: str, body: CompanyBoardBody, store: StoreDep) -> dict[str, Any]:
"""Attach a board to a company, or replace the one it has. The board is
fetched first and refused if it does not answer; replacing closes the
old board's open roles."""
if store.company(key) is None:
raise HTTPException(404, f"no such company: {key}")
try:
sub, found, closed = jobs.sources.set_board(store, key, body.board)
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
return {"source": _one_source(store, sub.id), "found": found, "closed": closed}
@router.delete("/companies/{key}/board")
def detach_company_board(key: str, store: StoreDep) -> dict[str, Any]:
"""Stop reading a company's board: its open roles close, the row stays."""
try:
closed = jobs.sources.detach_board(store, key)
except KeyError:
raise HTTPException(404, f"no such company: {key}") from None
except ValueError as exc:
raise HTTPException(409, str(exc)) from exc
return {"closed": closed}
class AffinityBody(BaseModel):
affinity: int
#: Whose affinity; the default agent when absent.
@@ -370,12 +406,13 @@ def _one_source(store: Store, sub_id: int) -> SourceOut:
@router.get("/sources")
def list_sources(store: StoreDep, config: ConfigDep) -> SourcesOut:
"""Every board, and every search not removed. A board switched off stays
listed, so it can be switched back on."""
"""Every board not detached, and every search not removed. A board
switched off stays listed, so it can be switched back on."""
counts = store.open_countries_by_subscription()
searches = [_source_out(s, counts.get(s.id, {}))
for s in store.subscriptions(source="search") if s.show]
boards = [_source_out(s, counts.get(s.id, {})) for s in store.subscriptions(source="ats")]
boards = [_source_out(s, counts.get(s.id, {}))
for s in store.subscriptions(source="ats") if s.show]
return SourcesOut(searches=searches, boards=boards,
adzuna_key=jobs.sources.has_key(config, "adzuna"))
@@ -454,8 +491,9 @@ class BoardBody(BaseModel):
@router.post("/boards", status_code=201)
def add_board(body: BoardBody, store: StoreDep) -> dict[str, Any]:
"""Follow a company's ATS board. It is fetched first, and refused if it
does not answer or lists nothing."""
"""Follow a company by its ATS board: `set_board` keyed by the name, so
an existing company gets it attached or replaced. The board is fetched
first and refused if it does not answer."""
try:
sub, found = jobs.sources.add_board(store, body.board, body.name)
except ValueError as exc:
+8 -5
View File
@@ -30,9 +30,10 @@ kept, so a bookmark still lands. A merged page's old path lands on its
section's anchor; the old Messages paths land on `#messages`, the log's
block at the end of Runs.
`FUNCTIONS` is `plugins.ats`'s, not `app`'s: the nine job functions are the
classifier's vocabulary, and this reaches `plugins/` the same way `app.cli`
does, since a plugin is app-agnostic and never reaches back into `app`. The
`FUNCTIONS` and `HOSTS` are `plugins.ats`'s, not `app`'s: the nine job
functions are the classifier's vocabulary and the hosts are what it parses,
and this reaches `plugins/` the same way `app.cli` does, since a plugin is
app-agnostic and never reaches back into `app`. The
Jobindex areas and Adzuna countries on the Sources page come from
`plugins.search` for the same reason.
"""
@@ -55,7 +56,7 @@ _ROOT = Path(__file__).resolve().parents[2]
if str(_ROOT) not in sys.path:
sys.path.insert(0, str(_ROOT))
from plugins.ats import FUNCTIONS # noqa: E402
from plugins.ats import FUNCTIONS, HOSTS # noqa: E402
from plugins.search import ADZUNA_COUNTRIES, JOBINDEX_AREAS # noqa: E402
TEMPLATE_DIR = Path(__file__).resolve().parent.parent / "templates"
@@ -118,6 +119,8 @@ REMOTE_OPTIONS = [(r, r.capitalize()) for r in REMOTE if r]
STATUS_OPTIONS = [(s, s.capitalize()) for s in STATUSES]
AREA_OPTIONS = list(JOBINDEX_AREAS.items())
COUNTRY_OPTIONS = [(c, c.upper()) for c in sorted(ADZUNA_COUNTRIES)]
#: The ATS hosts `plugins.ats` reads, for the Follow and Set board selects.
HOST_OPTIONS = list(HOSTS.items())
def asset(path: str) -> str:
@@ -183,7 +186,7 @@ def agents(request: Request) -> HTMLResponse:
@router.get("/settings/sources", response_class=HTMLResponse)
def sources(request: Request) -> HTMLResponse:
return page(request, "settings/sources.html", areas=AREA_OPTIONS,
countries=COUNTRY_OPTIONS)
countries=COUNTRY_OPTIONS, hosts=HOST_OPTIONS)
@router.get("/settings/account", response_class=HTMLResponse)