Merge branch 'main' into wp0-hosts

This commit is contained in:
Wolf committed 2026-09-29 19:49:00 +02:00
commit a7bb6c20ae
17 files changed
+1618 -313

No files matched your search

+125 -6
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|set-board|detach|discover|check
app companies seed|add|edit|checked|remove|by-hand|set-board|detach|discover|check
app searches add|list|remove
app agents list|prompt
app stages [extract|summarise on|off]
@@ -44,6 +44,8 @@ if str(_ROOT) not in sys.path:
def build_parser() -> argparse.ArgumentParser:
from app.models import HAND_REASONS
parser = argparse.ArgumentParser(
prog="app", description="roledesk: a job-search engine on desk and the pipeline queue.")
parser.add_argument("-c", "--config", default=None,
@@ -71,10 +73,34 @@ def build_parser() -> argparse.ArgumentParser:
seed = companies_sub.add_parser(
"seed", help="import seed/companies.json, and the boards it names for rows without one")
seed.add_argument("--path", default="seed/companies.json")
# One word after `add` is a company for the list checked by hand, two are
# a board and its company, which is what `add` meant before that list.
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")
"add", help="add NAME to the list checked by hand, or with BOARD NAME follow a "
"company by its board, attaching or replacing an existing one's")
add.add_argument("first", metavar="NAME|BOARD",
help="the company, or host:slug, e.g. greenhouse:acme, before its name")
add.add_argument("second", metavar="NAME", nargs="?")
add.add_argument("--careers-url", default="", help="its careers page, http or https")
add.add_argument("--note", default="")
add.add_argument("--reason", default="added", choices=HAND_REASONS, metavar="REASON",
help=f"one of {', '.join(repr(r) for r in HAND_REASONS)}")
edit = companies_sub.add_parser("edit", help="change a company's name, link, note or reason")
edit.add_argument("key")
edit.add_argument("--name")
edit.add_argument("--careers-url")
edit.add_argument("--note")
edit.add_argument("--reason", choices=HAND_REASONS, metavar="REASON",
help=f"one of {', '.join(repr(r) for r in HAND_REASONS)}")
checked = companies_sub.add_parser(
"checked", help="record that its careers page was looked at just now")
checked.add_argument("key")
remove = companies_sub.add_parser(
"remove", help="delete a company with no board on and no open roles")
remove.add_argument("key")
companies_sub.add_parser(
"by-hand", help="the companies checked by hand, never checked first, then the "
"longest ago")
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")
@@ -274,7 +300,15 @@ def run_companies(args: argparse.Namespace) -> int:
if args.action == "seed":
return seed_companies(store, args.path)
if args.action == "add":
return add_company(store, args.board, args.name)
return add_company(store, args)
if args.action == "edit":
return edit_company(store, args)
if args.action == "checked":
return company_checked(store, args.key)
if args.action == "remove":
return remove_company(store, args.key)
if args.action == "by-hand":
return list_by_hand(store)
if args.action == "set-board":
return set_board(store, args.key, args.board)
if args.action == "detach":
@@ -318,7 +352,25 @@ def discover_company(store: Store, name: str, domain: str, *, add: bool) -> int:
return 0
def add_company(store: Store, board: str, name: str) -> int:
def add_company(store: Store, args: argparse.Namespace) -> int:
"""`app companies add "Acme" [--careers-url URL] [--note TEXT] [--reason
REASON]` puts a company with no board on the list checked by hand;
`app companies add greenhouse:acme "Acme"` follows it by its board."""
if args.second is not None:
return add_company_by_board(store, args.first, args.second)
from app import jobs
try:
company = jobs.sources.add_by_hand(store, args.first, careers_url=args.careers_url,
notes=args.note, hand_reason=args.reason)
except ValueError as exc:
print(f"companies add: {exc}", file=sys.stderr)
return 1
print(json.dumps({"key": company.key, "hand_reason": company.hand_reason}))
return 0
def add_company_by_board(store: Store, board: str, name: str) -> int:
"""`app companies add greenhouse:acme "Acme"`: fetch the board first
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`."""
@@ -334,6 +386,73 @@ def add_company(store: Store, board: str, name: str) -> int:
return 0
def edit_company(store: Store, args: argparse.Namespace) -> int:
"""`app companies edit acme --careers-url https://acme.example/jobs`: only
the options given change; see `jobs.sources.edit_company`."""
from app import jobs
given = {"name": args.name, "careers_url": args.careers_url, "notes": args.note,
"hand_reason": args.reason}
try:
company = jobs.sources.edit_company(
store, args.key, **{f: v for f, v in given.items() if v is not None})
except KeyError:
print(f"companies edit: no company {args.key!r}", file=sys.stderr)
return 1
except ValueError as exc:
print(f"companies edit: {exc}", file=sys.stderr)
return 1
print(json.dumps({"key": company.key, "name": company.name,
"careers_url": company.careers_url, "notes": company.notes,
"hand_reason": company.hand_reason}))
return 0
def company_checked(store: Store, key: str) -> int:
"""`app companies checked acme`: its careers page was looked at just now,
which the Watchlist keeps as `careers_opened_at`, the same stamp opening
the page from there sets."""
if store.company(key) is None:
print(f"companies checked: no company {key!r}", file=sys.stderr)
return 1
company = store.update_company(key, careers_opened_at=store.now())
print(json.dumps({"key": key, "careers_opened_at": company.careers_opened_at}))
return 0
def remove_company(store: Store, key: str) -> int:
"""`app companies remove acme`: refused for a company still read, see
`jobs.sources.remove_company`."""
from app import jobs
try:
jobs.sources.remove_company(store, key)
except KeyError:
print(f"companies remove: no company {key!r}", file=sys.stderr)
return 1
except ValueError as exc:
print(f"companies remove: {exc}", file=sys.stderr)
return 1
print(json.dumps({"key": key, "removed": True}))
return 0
def list_by_hand(store: Store) -> int:
"""`app companies by-hand`: the companies with no board shown that are not
known from a search only, one line each, never opened first and then the
longest ago; `watch` is the Watchlist's rating, yes, no or a dash for
unrated. See `jobs.sources.by_hand`."""
from app import jobs
rows = jobs.sources.by_hand(store)
for c in rows:
watch = "-" if c.watch is None else "yes" if c.watch else "no"
opened = c.careers_opened_at[:10] or "never"
print(f"{c.name:30} {c.hand_reason or '-':8} {watch:4} {opened:10} {c.careers_url}")
print(f"{len(rows)} by hand")
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."""
+124 -8
View File
@@ -15,9 +15,10 @@ import json
import os
from pathlib import Path
from typing import TYPE_CHECKING, Any
from urllib.parse import urlsplit
from app.config import Config
from app.models import Subscription, company_key
from app.models import HAND_REASONS, Company, Subscription, company_key
from app.storage import Store
from app.jobs.pull import FAILING, search_target
@@ -45,8 +46,9 @@ def set_board(store: Store, key: str, board: str, *, name: str = "",
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.
The row's `ats` and `ats_slug` become the board's host and slug, its
`careers_url` the board's page where it was empty or the old board's, and
its `hand_reason` empty, since a company that is read is not read by hand.
`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
@@ -81,7 +83,7 @@ def set_board(store: Store, key: str, board: str, *, name: str = "",
writes["careers_url"] = careers_url(board)
else:
writes.setdefault("careers_url", careers_url(board))
writes.update(ats=host, ats_slug=slug)
writes.update(ats=host, ats_slug=slug, hand_reason="")
before = store.company_subscription(key)
_company, sub, closed = store.set_company_board(key, board, host=host, name=name,
fields=writes)
@@ -154,12 +156,116 @@ def add_discovered(store: Store, name: str, domain: str,
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")
# A link somebody typed is kept: discovery's is only a guess at the page.
store.update_company(key, ats=found.ats, ats_slug=found.ats_slug,
careers_url=found.careers_url or company.careers_url,
careers_url=company.careers_url or found.careers_url,
**({"domain": domain} if not company.domain else {}))
return key, 0
def known_from_search_only(company: Company, ever_boarded: set[str]) -> bool:
"""A row that exists only because a search listed its roles and somebody
judged it (`Store.set_affinity`): no board, not even a detached one
(`ever_boarded`, the keys of every `ats` subscription), and none of the
facts every way of following a company or listing it by hand writes."""
return not (company.key in ever_boarded or company.ats or company.careers_url
or company.domain or company.hand_reason)
def by_hand(store: Store) -> list[Company]:
"""The list checked by hand: companies with no board shown that are not
known from a search only. Never opened first, then the longest ago
(`careers_opened_at`, the Watchlist's stamp); the name breaks a tie."""
boards = store.company_boards()
ever_boarded = {company_key(s.company) for s in store.subscriptions(source="ats")}
rows = [c for c in store.companies()
if c.key not in boards and not known_from_search_only(c, ever_boarded)]
return sorted(rows, key=lambda c: (c.careers_opened_at, c.name.casefold()))
class Conflict(ValueError):
"""A change refused because of what the company already is, not because of
what was asked for: the pages answer it with 409, not 422."""
def check_careers_url(url: str) -> str:
"""`url` stripped; ValueError unless it is empty or an http(s) link. The
page puts it in an `href`, where `javascript:` would run."""
url = url.strip()
if url:
parts = urlsplit(url)
if parts.scheme not in ("http", "https") or not parts.netloc:
raise ValueError("The careers link must start with http:// or https://.")
return url
def add_by_hand(store: Store, name: str, *, careers_url: str = "", notes: str = "",
hand_reason: str = "added") -> Company:
"""A company with no board, put on the list checked by hand. Raises
Conflict when the key its name folds to is taken, ValueError for a name
with no letters, a link that is no http(s) URL or a reason outside
`HAND_REASONS`."""
link = check_careers_url(careers_url)
key = company_key(name)
if key and store.company(key) is not None:
raise Conflict(f"{name.strip()} is on the list already as {key}.")
return store.add_company(name, key=key, careers_url=link, notes=notes,
hand_reason=hand_reason)
def edit_company(store: Store, key: str, **fields: str) -> Company:
"""Change a company's `name`, `careers_url`, `notes` or `hand_reason`; the
key never changes. A new name is Conflict for a company with a board
subscription, shown or not, since the subscription is found by the key
its company name folds to and would be lost. Raises KeyError for an
unknown company and ValueError for a blank name, a link that is no http(s)
URL or a reason outside `HAND_REASONS`."""
unknown = set(fields) - {"name", "careers_url", "notes", "hand_reason"}
if unknown:
raise ValueError(f"not a field to edit: {', '.join(sorted(unknown))}")
company = store.company(key)
if company is None:
raise KeyError(key)
if "careers_url" in fields:
fields["careers_url"] = check_careers_url(fields["careers_url"])
if "name" in fields:
fields["name"] = fields["name"].strip()
if not fields["name"]:
raise ValueError("A company needs a name.")
if fields["name"] != company.name and store.company_subscription(key) is not None:
raise Conflict(f"{company.name} has a board, which is found by its name; "
"detach the board first.")
return store.update_company(key, **fields)
def remove_company(store: Store, key: str) -> None:
"""Delete company `key` and every agent's stance on it. Raises KeyError
for an unknown company and Conflict for one still read: a company with
a board on (`show`, as `detach_board` decides) or with open roles, which
would otherwise vanish from the list with nothing said. A detached board
is no board, since nothing reads it and its roles are closed; its
subscription row stays, and follows the company if it comes back."""
if store.company(key) is None:
raise KeyError(key)
sub = store.company_subscription(key)
if sub is not None and sub.show:
raise Conflict(f"{key} is read from {sub.target}; detach the board first")
if store.open_role_counts().get(key):
raise Conflict(f"{key} has open roles; detach its board first")
store.remove_company(key)
def _fill_empty(store: Store, key: str, **facts: str) -> None:
"""Write each of `facts` to company `key` where the stored value is
empty: what a seed may add to a row that exists, since a person's link or
reason is never overwritten."""
company = store.company(key)
assert company is not None
fill = {f: v for f, v in facts.items() if v and not getattr(company, f)}
if fill:
store.update_company(key, **fill)
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
@@ -171,8 +277,10 @@ def seed_companies(store: Store, path: str | Path) -> dict[str, Any]:
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`
status are never touched; its `careers_url` and `hand_reason` are filled
where empty, so the seed can hand a row its link and its reason but never
overwrite the one a person set. 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
@@ -190,8 +298,15 @@ def seed_companies(store: Store, path: str | Path) -> dict[str, Any]:
board = ""
facts = {f: str(row.get(f) or "") for f in ("domain", "country", "city",
"careers_url", "ats", "ats_slug")}
reason = str(row.get("hand_reason") or "")
if reason not in HAND_REASONS:
problems.append(f"{key}: {reason!r} is not a hand_reason; kept without it")
reason = ""
exists = store.company(key) is not None
if exists:
_fill_empty(store, key, hand_reason=reason)
if exists and (not board or store.company_subscription(key) is not None):
_fill_empty(store, key, careers_url=facts["careers_url"])
skipped += 1
continue
if board:
@@ -204,13 +319,14 @@ def seed_companies(store: Store, path: str | Path) -> dict[str, Any]:
except ValueError as exc:
problems.append(f"{key}: {exc}")
if exists:
_fill_empty(store, key, careers_url=facts["careers_url"])
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)
store.add_company(name, key=key, hand_reason=reason, **facts)
added += 1
return {"added": added, "boards": boards, "skipped": skipped, "total": len(entries),
"problems": problems}
+13
View File
@@ -644,6 +644,16 @@ STATUSES: tuple[str, ...] = get_args(Status)
#: -1 mute, 0 neutral, 1 interested, 2 favourite (skips gates, floors the score).
AFFINITY = range(-1, 3)
#: Why a company is on the list checked by hand. `unread` is a host the app
#: could read and has no parser for yet, `robots` a site whose robots.txt
#: disallows it, `blocked` one that answers a program with a challenge, `key`
#: one whose API answers only with a key lifted from its own script, `group` a
#: company that sits inside its owner's board, `gone` one whose site is dead,
#: and `added` one put there by hand or by an import and not looked at. ''
#: is none of these: the company is read, or is not a matter for the list.
HandReason = Literal["", "unread", "robots", "blocked", "key", "group", "gone", "added"]
HAND_REASONS: tuple[str, ...] = get_args(HandReason)
# -------------------------------------------------------------- posting dates
@@ -929,6 +939,9 @@ class Company(Model):
watch: int | None = None
#: When the careers page was last opened from the Watchlist; "" never.
careers_opened_at: str = ""
#: Why the company is read by hand, one of `HAND_REASONS`; "" when it is
#: not on that list.
hand_reason: str = ""
created_at: str
updated_at: str
+5 -1
View File
@@ -1130,7 +1130,8 @@ table.applications td[data-label="Saved"] { white-space: nowrap; color: var(--di
.agent-form h2, .agent-form h3 { font-size: 1rem; margin: 0; }
.agent-form label { display: flex; flex-direction: column; gap: .2rem; font-size: .9rem; }
.agent-form label.inline { flex-direction: row; align-items: center; gap: .4rem; }
.agent-form input[type="text"], .agent-form textarea, .agent-form input[type="number"] {
.agent-form input[type="text"], .agent-form textarea, .agent-form input[type="number"],
.agent-form input[type="url"] {
background: var(--bg); border: 1px solid var(--line);
border-radius: .3rem; padding: .35rem .5rem; width: 100%;
}
@@ -1253,6 +1254,9 @@ table.applications td[data-label="Saved"] { white-space: nowrap; color: var(--di
}
.crow .board-edit input { flex: 1 1 8rem; min-width: 0; }
.crow .sub .failing { color: var(--warn); }
/* A Watchlist row's note, a line of its own: the owner's line breaks kept,
and a pasted URL broken rather than widening a phone's page. */
.crow .sub.notes { white-space: pre-line; overflow-wrap: anywhere; }
.linky {
padding: 0; border: 0; background: none; font-size: .8rem;
+256 -71
View File
@@ -2,13 +2,20 @@
* going through their careers pages by hand.
*
* The list is app.js's shared company list (`/api/companies`), narrowed to
* the rule the "Not readable yet" filter of Company boards uses (no board
* subscription, not from a search), plus every company whose board is
* failing. The rating (`watch`: null unrated, 1 yes, 0 no) is global, not a
* search agent's affinity, and is set with `POST .../watch`. Opening the
* careers page stamps `careers_opened_at` (`POST .../opened`), so the row can
* say when, and the On the list filter sorts what was opened longest ago
* first. The filter is remembered per browser, and opens on Unrated.
* the by-hand list (`by_hand`: no board shown, not known from a search only),
* plus every company whose board is failing. The rating (`watch`: null
* unrated, 1 yes, 0 no) is global, not a search agent's affinity, and is set
* with `POST .../watch`. Opening the careers page stamps `careers_opened_at`
* (`POST .../opened`), so the row can say when, and the On the list filter
* sorts what was opened longest ago first. The filter is remembered per
* browser, and opens on Unrated.
*
* New company and Edit are the Job boards form of Sources (sources.js): Edit
* turns a row into the form from the page's `<template>`, in place, New puts
* a blank one on top, one is open at a time, and Save and Cancel put it
* away. New is `POST /api/companies`, Edit a `PATCH` of the fields that
* changed, and Remove a `DELETE`; a refusal is `api()`'s toast with the
* server's sentence, and the catch blocks here only put a control back.
*/
(function () {
"use strict";
@@ -22,8 +29,13 @@
];
const DAY = 24 * 60 * 60 * 1000;
/** The key of the row whose careers link editor is open, or null. */
const NEW = "new";
/** @type {string | "new" | null} the row in edit mode: a company's key,
* NEW for the blank form on top, null for none */
let editing = null;
/** @type {HTMLFormElement | null} that form, kept across renders so a
* rating set on another row does not wipe what is being typed */
let editor = null;
function savedFilter() {
try {
@@ -38,10 +50,17 @@
try { localStorage.setItem(FILTER, value); } catch (err) { /* not remembered */ }
}
/** On the by-hand list: the server says so, or, from a server without
`by_hand`, no board and not known from a search only. */
function byHand(company) {
return "by_hand" in company
? Boolean(company.by_hand)
: company.subscription_id == null && !company.from_search;
}
/** The companies the tab is about, before any filter. */
function watched() {
return [...companies.values()].filter(
(c) => (c.subscription_id == null && !c.from_search) || c.failing_since);
return [...companies.values()].filter((c) => byHand(c) || c.failing_since);
}
function matchesFilter(company, filter) {
@@ -53,6 +72,24 @@
}
}
/** A `hand_reason` in words, from the options the page rendered into the
form: "no reader yet". "" for none given. */
function reasonWords(value) {
if (!value) return "";
const option = [...$("#company-form-template").content.querySelector("#cf-reason").options]
.find((o) => o.value === value);
const label = option ? option.textContent : value;
return label.charAt(0).toLowerCase() + label.slice(1);
}
function matchesQuery(company, q) {
return !q || company.name.toLowerCase().includes(q)
|| (company.board || company.ats || "").includes(q)
|| (company.country || "").toLowerCase() === q
|| (company.notes || "").toLowerCase().includes(q)
|| reasonWords(company.hand_reason).includes(q);
}
function ago(iso) {
if (!iso) return "not opened yet";
const days = Math.floor((Date.now() - new Date(iso).getTime()) / DAY);
@@ -100,13 +137,30 @@
return span;
}
function badge(text) {
const span = document.createElement("span");
span.className = "badge";
span.textContent = text;
return span;
}
function linky(text, onClick) {
const button = document.createElement("button");
button.type = "button";
button.className = "linky";
button.textContent = text;
button.addEventListener("click", () => onClick(button));
return button;
}
function subLine(company, rerender) {
const sub = document.createElement("span");
sub.className = "sub";
const badge = document.createElement("span");
badge.className = "badge";
badge.textContent = company.board || company.ats || "board not found";
sub.appendChild(badge);
// The host, then why the company is read by hand. Without a reason the
// row says what it did before there were reasons: "board not found".
const host = company.board || company.ats || (company.hand_reason ? "" : "board not found");
if (host) sub.appendChild(badge(host));
if (company.hand_reason) sub.appendChild(badge(reasonWords(company.hand_reason)));
const place = [company.city, (company.country || "").toUpperCase()].filter(Boolean).join(", ");
if (place) sub.append(` ${place}`);
if (company.failing_since) {
@@ -128,16 +182,9 @@
sub.appendChild(link);
sub.append(` · ${ago(company.careers_opened_at)} `);
}
const edit = document.createElement("button");
edit.type = "button";
edit.className = "linky";
edit.textContent = company.careers_url ? "Edit link" : "Add careers page";
edit.setAttribute("aria-expanded", String(editing === company.key));
edit.addEventListener("click", () => {
editing = editing === company.key ? null : company.key;
rerender();
});
sub.appendChild(edit);
// Edit is also how a link is set: the form opens on the careers page box.
sub.append(linky("Edit", () => openForm(company)), " ",
linky("Remove", (button) => removeCompany(company, button)));
return sub;
}
@@ -154,39 +201,23 @@
rerender();
}
function linkEditor(company, rerender) {
const form = document.createElement("form");
form.className = "board-edit";
form.autocomplete = "off";
const input = document.createElement("input");
input.type = "url";
input.spellcheck = false;
input.placeholder = "https://";
input.value = company.careers_url || "";
input.setAttribute("aria-label", `${company.name}'s careers page`);
const save = document.createElement("button");
save.type = "submit";
save.textContent = "Save";
const cancel = document.createElement("button");
cancel.type = "button";
cancel.className = "linky";
cancel.textContent = "Cancel";
cancel.addEventListener("click", () => { editing = null; rerender(); });
form.append(input, save, cancel);
form.addEventListener("submit", async (event) => {
event.preventDefault();
save.disabled = true;
try {
const updated = await api(`/api/companies/${encodeURIComponent(company.key)}/careers`,
{ method: "POST", body: { careers_url: input.value.trim() } });
company.careers_url = updated.careers_url;
editing = null;
rerender();
} catch (err) {
save.disabled = false;
}
});
return form;
function row(company) {
const row = document.createElement("div");
row.className = "crow";
row.dataset.key = company.key;
const name = document.createElement("span");
name.className = "name";
name.textContent = company.name;
row.appendChild(name);
row.appendChild(ratingControl(company, render));
row.appendChild(subLine(company, render));
if (company.notes) {
const note = document.createElement("span");
note.className = "sub notes";
note.textContent = company.notes;
row.appendChild(note);
}
return row;
}
/** The filter's options with their counts, kept on the chosen one. */
@@ -208,10 +239,9 @@
drawFilter(all);
const q = $("#w-q").value.trim().toLowerCase();
const filter = $("#w-filter").value;
const rows = all
.filter((c) => !q || c.name.toLowerCase().includes(q)
|| (c.board || c.ats || "").includes(q) || (c.country || "").toLowerCase() === q)
.filter((c) => matchesFilter(c, filter));
// The row being edited stays, whatever the filter says, so its form does.
const rows = all.filter((c) => c.key === editing
|| (matchesQuery(c, q) && matchesFilter(c, filter)));
// Overdue first on the list, never opened on top (the empty stamp sorts
// before any date); every other filter is by name.
rows.sort((a, b) => (filter === "yes"
@@ -219,21 +249,175 @@
|| a.name.localeCompare(b.name));
const body = $("#watchlist-list");
body.replaceChildren();
if (editing === NEW) body.appendChild(editor);
for (const company of rows) {
const row = document.createElement("div");
row.className = "crow";
const name = document.createElement("span");
name.className = "name";
name.textContent = company.name;
row.appendChild(name);
row.appendChild(ratingControl(company, render));
row.appendChild(subLine(company, render));
if (editing === company.key) row.appendChild(linkEditor(company, render));
body.appendChild(row);
body.appendChild(editing === company.key ? editor : row(company));
}
$("#watchlist-count").textContent = count(rows.length, "company", "companies");
}
// ---------------------------------------------------------------- the form
function form(company) {
const f = $("#company-form-template").content.querySelector("form").cloneNode(true);
$("#company-form-title", f).textContent = company ? `Edit ${company.name}` : "New company";
$("#cf-name", f).value = company ? company.name : "";
// A company with a board keeps its name: the board is found by it.
const kept = Boolean(company && company.subscription_id != null);
$("#cf-name", f).readOnly = kept;
$("#cf-name-hint", f).hidden = !kept;
$("#cf-url", f).value = company ? company.careers_url || "" : "";
$("#cf-reason", f).value = company ? company.hand_reason || "" : "added";
$("#cf-notes", f).value = company ? company.notes || "" : "";
f.addEventListener("input", () => { f.dataset.dirty = "true"; });
$("#cf-cancel", f).addEventListener("click", () => { if (close()) render(); });
f.addEventListener("submit", saveCompany);
return f;
}
// Put the open form away, asking first if it holds changes. False when the
// answer was to keep them.
function close() {
if (editor && editor.dataset.dirty
&& !window.confirm("Discard the changes to this company?")) {
return false;
}
editing = null;
editor = null;
return true;
}
// Edit `company` in place of its row, or a new one on top of the list.
function openForm(company) {
const want = company ? company.key : NEW;
if (editing !== want) {
if (!close()) return;
editing = want;
editor = form(company);
$("#watchlist-answer").replaceChildren();
render();
}
editor.scrollIntoView({ behavior: "smooth", block: "nearest" });
$(company ? "#cf-url" : "#cf-name", editor).focus({ preventScroll: true });
}
function formBody(f) {
return {
name: $("#cf-name", f).value.trim(),
careers_url: $("#cf-url", f).value.trim(),
hand_reason: $("#cf-reason", f).value,
notes: $("#cf-notes", f).value.trim(),
};
}
/** A new company is unrated: if the filter or the text would hide it, they
change to show it, since the owner just asked for it. */
function reveal(company) {
if (!matchesFilter(company, $("#w-filter").value)) {
$("#w-filter").value = "unrated";
saveFilter("unrated");
}
if (!matchesQuery(company, $("#w-q").value.trim().toLowerCase())) $("#w-q").value = "";
}
async function saveCompany(event) {
event.preventDefault();
const f = event.target;
const button = $("button[type=submit]", f);
const body = formBody(f);
const company = editing === NEW ? null : companies.get(editing);
// Only what changed, so a company with a board is not sent the name it
// may not change.
const patch = {};
if (company) {
for (const [field, value] of Object.entries(body)) {
if (value !== (company[field] || "")) patch[field] = value;
}
}
button.disabled = true;
let answer = company;
try {
if (!company) {
answer = await api("/api/companies", { method: "POST", body });
} else if (Object.keys(patch).length) {
answer = await api(`/api/companies/${encodeURIComponent(company.key)}`,
{ method: "PATCH", body: patch });
}
} catch (err) {
button.disabled = false;
if (!company && err.status === 409) await taken(body.name, err.detail);
return;
}
if (company) {
Object.assign(company, answer);
} else {
companies.set(answer.key, answer);
reveal(answer);
}
editing = null;
editor = null;
$("#watchlist-answer").textContent = `${company ? "Saved" : "Added"} ${answer.name}.`;
render();
const shown = $(`#watchlist-list [data-key="${CSS.escape(answer.key)}"]`);
if (shown) shown.scrollIntoView({ behavior: "smooth", block: "nearest" });
}
// New refused, since the key its name folds to is taken, which the toast
// said. If that company is on this list, offer to edit it instead; if not,
// say where it is. The server's sentence ends "as <key>.", which finds it
// when the name typed is not the one it has ("Acme GmbH" for "Acme").
async function taken(name, detail) {
try {
await loadCompanies();
} catch (err) {
return;
}
render();
const said = / as (\S+)\.$/.exec(detail || "");
const wanted = name.toLowerCase();
const existing = (said && companies.get(said[1]))
|| [...companies.values()].find((c) => c.name.toLowerCase() === wanted);
if (!existing) return;
if (byHand(existing) || existing.failing_since) {
if (window.confirm(`${existing.name} is on the Watchlist already. Edit it instead?`)) {
delete editor.dataset.dirty;
openForm(existing);
}
return;
}
const why = existing.board ? "the app reads its board" : "it is known from a job board search";
const link = document.createElement("a");
link.href = "/settings/sources#company-boards";
link.textContent = "Settings, Sources, Company boards";
$("#watchlist-answer").replaceChildren(
`${existing.name} is not on the Watchlist, since ${why}; it is under `, link, ".");
}
// ---------------------------------------------------------------- actions
async function removeCompany(company, button) {
if (!window.confirm(`Remove ${company.name}? Its rating, note and careers link go with it.`)) {
return;
}
button.disabled = true;
try {
// A company with a board or open roles is refused, and the toast says which.
await api(`/api/companies/${encodeURIComponent(company.key)}`, { method: "DELETE" });
} catch (err) {
button.disabled = false;
return;
}
companies.delete(company.key);
if (editing === company.key) {
editing = null;
editor = null;
}
$("#watchlist-answer").textContent = `Removed ${company.name}.`;
render();
}
// -------------------------------------------------------------------- init
document.addEventListener("DOMContentLoaded", async () => {
if (!$("#watchlist-list")) return;
try {
@@ -248,5 +432,6 @@
saveFilter($("#w-filter").value);
render();
});
$("#w-add").addEventListener("click", () => openForm(null));
});
})();
+11 -2
View File
@@ -109,7 +109,9 @@ CREATE TABLE IF NOT EXISTS role_tags (
-- '' where its URL carries none, kept for the parser written later.
-- watch is the Watchlist's rating, global and not an agent's: NULL unrated, 1
-- worth checking by hand, 0 not; careers_opened_at when its careers page was
-- last opened from there.
-- last opened from there, which is also when a person last looked at it.
-- hand_reason is why a person reads the careers page (models.HAND_REASONS),
-- '' when nobody has to.
CREATE TABLE IF NOT EXISTS companies (
key TEXT PRIMARY KEY,
name TEXT NOT NULL,
@@ -124,7 +126,8 @@ CREATE TABLE IF NOT EXISTS companies (
city TEXT NOT NULL DEFAULT '',
ats_slug TEXT NOT NULL DEFAULT '',
watch INTEGER CHECK (watch IN (0, 1)),
careers_opened_at TEXT NOT NULL DEFAULT ''
careers_opened_at TEXT NOT NULL DEFAULT '',
hand_reason TEXT NOT NULL DEFAULT ''
);
-- The targets desk's runner hands to plugins. newsdesk's shape, with its two
@@ -436,6 +439,12 @@ ALTER TABLE scores ADD COLUMN prompt TEXT NOT NULL DEFAULT '';
"when its careers page was last opened", """
ALTER TABLE companies ADD COLUMN watch INTEGER CHECK (watch IN (0, 1));
ALTER TABLE companies ADD COLUMN careers_opened_at TEXT NOT NULL DEFAULT '';
"""),
# Why a person reads the company's careers page by hand, one of
# models.HAND_REASONS; '' when nobody has to. When it was last looked at
# is careers_opened_at.
(16, "companies.hand_reason: why a company is read by hand", """
ALTER TABLE companies ADD COLUMN hand_reason TEXT NOT NULL DEFAULT '';
"""),
)
+23 -6
View File
@@ -21,7 +21,7 @@ import numpy as np
from desk.models import Item
from app.models import (
AFFINITY, REMOTE, STATUSES, Agent, Application, ApplicationEvent, Candidate,
AFFINITY, HAND_REASONS, REMOTE, STATUSES, Agent, Application, ApplicationEvent, Candidate,
Company, Gate, Limits, Prompt, Role, RoleRow, ScoredRole, Subscription, Weights,
check_prompts, company_key, country_of, excerpt, place_key, posted_at, posted_host,
remote_of, title_key,
@@ -94,7 +94,7 @@ _EXCERPT_SOURCE = "COALESCE(NULLIF(roles.summary, ''), roles.description)"
_EXCERPT_RAW = 240
_COMPANY_FIELDS = ("name", "domain", "status", "careers_url", "notes", "ats", "country", "city",
"ats_slug", "watch", "careers_opened_at")
"ats_slug", "watch", "careers_opened_at", "hand_reason")
#: 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
@@ -1163,18 +1163,21 @@ 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 = "", ats_slug: str = "") -> Company:
"""Raises ValueError on a key already taken."""
city: str = "", ats_slug: str = "",
hand_reason: str = "") -> Company:
"""Raises ValueError on a key already taken or a `hand_reason` outside
`HAND_REASONS`."""
name = name.strip()
key = key or company_key(name)
if not key:
raise ValueError("a company needs a name")
_check_hand_reason(hand_reason)
try:
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})
"ats_slug": ats_slug, "hand_reason": hand_reason})
except sqlite3.IntegrityError as exc:
raise ValueError(f"company {key!r} already exists") from exc
return self._company(key)
@@ -1238,6 +1241,8 @@ class Store:
unknown = set(fields) - set(_COMPANY_FIELDS)
if unknown:
raise ValueError(f"not a company field: {', '.join(sorted(unknown))}")
if "hand_reason" in fields:
_check_hand_reason(fields["hand_reason"])
if fields:
sets = ", ".join(f"{f}=?" for f in fields)
changed = self._write(f"UPDATE companies SET {sets}, updated_at=? WHERE key=?",
@@ -1247,7 +1252,13 @@ class Store:
return self._company(key)
def remove_company(self, key: str) -> bool:
return self._write("DELETE FROM companies WHERE key=?", (key,)) > 0
"""Delete the row and every agent's stance on it, in one transaction:
`agent_companies` holds the key with no foreign key to hold it back, so
a row left behind would give a company added again under the same name
an affinity it never got. Roles and subscriptions are not touched."""
with self.transaction() as conn:
conn.execute("DELETE FROM agent_companies WHERE company_key=?", (key,))
return conn.execute("DELETE FROM companies WHERE key=?", (key,)).rowcount > 0
def _company(self, key: str, agent_id: int | None = None) -> Company:
found = self.company(key, agent_id)
@@ -1542,6 +1553,12 @@ def _check_status(status: str) -> None:
f"({', '.join(STATUSES)})")
def _check_hand_reason(reason: Any) -> None:
if reason not in HAND_REASONS:
raise ValueError(f"hand_reason is one of {', '.join(repr(r) for r in HAND_REASONS)}, "
f"not {reason!r}")
def _check_affinity(affinity: Any) -> None:
if isinstance(affinity, bool) or not isinstance(affinity, int) or affinity not in AFFINITY:
raise ValueError(f"affinity is -1, 0, 1 or 2, not {affinity!r}")
+40 -2
View File
@@ -1,19 +1,57 @@
{% extends "base.html" %}
{% block title %}Watchlist — roledesk{% endblock %}
{# The form is a `<template>` for the reason the Job boards one on Sources
is: one company is edited at a time, so its ids stay unique. watchlist.js
puts it in place of a row on Edit, and on top of the list on New. The
reason's options are `HAND_REASONS` of app/models.py, in the words a row's
badge uses; watchlist.js reads the words off them. #}
{% block content %}
<h1>Watchlist</h1>
<p class="lede">The companies roledesk knows but cannot read a board of, so their roles are not in Roles. Mark the ones worth checking by hand and open their careers page from here.</p>
<form class="filters" autocomplete="off" onsubmit="return false">
<input type="search" id="w-q" placeholder="Filter by name, host or country code" aria-label="Filter companies">
<input type="search" id="w-q" placeholder="Filter by name, host, country code, reason or note" aria-label="Filter companies">
{# The options and their counts are drawn by watchlist.js, which also
remembers the choice. #}
<select id="w-filter" aria-label="Show"></select>
</form>
<p id="watchlist-count" class="count" role="status"></p>
<div class="agents-head">
<p id="watchlist-count" class="count" role="status"></p>
<button type="button" id="w-add">New company</button>
</div>
<p id="watchlist-answer" class="count" role="status"></p>
<div id="watchlist-list" class="crows"></div>
<template id="company-form-template">
<form id="company-form" class="agent-form source-form" autocomplete="off">
<h3 id="company-form-title">New company</h3>
<div class="form-row">
<label>Name <input type="text" id="cf-name" required placeholder="Acme">
<span class="hint" id="cf-name-hint" hidden>Kept while it has a board, which is found by its name.</span></label>
<label>Reason
<select id="cf-reason">
<option value="unread">No reader yet</option>
<option value="robots">Site disallows reading</option>
<option value="blocked">Site blocks programs</option>
<option value="key">Needs a key</option>
<option value="group">Inside another company's board</option>
<option value="gone">No careers page</option>
<option value="added">Added by hand</option>
<option value="">Not given</option>
</select></label>
</div>
<label>Careers page
<input type="url" id="cf-url" pattern="https?://.+" placeholder="https://acme.com/careers" spellcheck="false">
<span class="hint">The page with its roles, which the row links to.</span></label>
<label>Note <textarea id="cf-notes" rows="3" placeholder="Where the roles are, what to search for"></textarea></label>
<div class="agent-actions">
<button type="submit">Save</button>
<button type="button" id="cf-cancel" class="secondary">Cancel</button>
</div>
</form>
</template>
{% endblock %}
{% block scripts %}
+96 -16
View File
@@ -17,7 +17,7 @@ from pydantic import BaseModel, Field
from app import jobs
from app.models import (
AFFINITY, Agent, Application, Company, Gate, Limits, Prompts, Role, RoleRow,
ScoredRole, Status, Subscription, Weights, company_key,
HandReason, ScoredRole, Status, Subscription, Weights, company_key,
)
from app.storage import Store
from app.web.deps import ConfigDep, StoreDep
@@ -303,12 +303,17 @@ class CompanyOut(BaseModel):
the board has failed on every fetch and why it last did, both empty
while it answers. `from_search` marks a row that exists only because a
search listed its roles and somebody judged it (`Store.set_affinity`):
no board, not even a detached one, and no `ats`, `careers_url` or
`domain`, which every way of following a company writes one of.
`watch` and `careers_opened_at` are the Watchlist's (`Company`'s)."""
no board, not even a detached one, and no `ats`, `careers_url`, `domain`
or `hand_reason`, which every way of following a company or listing it by
hand writes one of (`jobs.sources.known_from_search_only`). `watch` and
`careers_opened_at` are the Watchlist's (`Company`'s), the latter also
when a person last looked at the careers page. `by_hand` marks a company
with no board shown that is not `from_search`, and `hand_reason` says why
it is read by hand (`app.models.HAND_REASONS`)."""
key: str
name: str
notes: str = ""
board: str
subscription_id: int | None = None
on: bool | None = None
@@ -325,6 +330,8 @@ class CompanyOut(BaseModel):
failing_since: str = ""
failing_reason: str = ""
from_search: bool = False
hand_reason: str = ""
by_hand: bool = False
def _company_boards(store: Store) -> dict[str, tuple[int, str, bool, str]]:
@@ -342,30 +349,101 @@ def _company_boards(store: Store) -> dict[str, tuple[int, str, bool, str]]:
return boards
@router.get("/companies")
def list_companies(store: StoreDep, agent: int | None = None) -> list[CompanyOut]:
"""Every company, with `affinity` as `agent` (the default agent when
absent) has it; 0 throughout when there is no agent."""
def _company_outs(store: Store, agent: int | None) -> list[CompanyOut]:
boards = _company_boards(store)
ever_boarded = {company_key(s.company) for s in store.subscriptions(source="ats")}
counts = store.open_role_counts()
failing = jobs.pull.failing_boards(store)
out = []
for c in store.companies(_agent_id(store, agent)):
for c in store.companies(agent):
sub_id, host, on, target = boards.get(c.key, (None, "", None, ""))
since, reason = failing.get(target, ("", ""))
out.append(CompanyOut(key=c.key, name=c.name, board=host,
from_search = jobs.sources.known_from_search_only(c, ever_boarded)
out.append(CompanyOut(key=c.key, name=c.name, notes=c.notes, board=host,
subscription_id=sub_id, on=on, affinity=c.affinity,
open_roles=counts.get(c.key, 0), ats=c.ats,
ats_slug=c.ats_slug, careers_url=c.careers_url,
country=c.country, city=c.city, domain=c.domain,
watch=c.watch, careers_opened_at=c.careers_opened_at,
failing_since=since, failing_reason=reason,
from_search=not (c.key in ever_boarded or c.ats
or c.careers_url or c.domain)))
from_search=from_search, hand_reason=c.hand_reason,
by_hand=c.key not in boards and not from_search))
return out
def _one_company(store: Store, key: str) -> CompanyOut:
"""`key` as the list shows it, with the default agent's affinity."""
return next(c for c in _company_outs(store, _agent_id(store, None)) if c.key == key)
@router.get("/companies")
def list_companies(store: StoreDep, agent: int | None = None) -> list[CompanyOut]:
"""Every company, with `affinity` as `agent` (the default agent when
absent) has it; 0 throughout when there is no agent."""
return _company_outs(store, _agent_id(store, agent))
class NewCompanyBody(BaseModel):
name: str
careers_url: str = ""
notes: str = ""
hand_reason: HandReason = "added"
@router.post("/companies", status_code=201)
def add_company(body: NewCompanyBody, store: StoreDep) -> CompanyOut:
"""A company put on the list checked by hand: no board, `hand_reason`
`added` unless it says another. 409 when its key, from the name, is taken."""
try:
company = jobs.sources.add_by_hand(store, body.name, careers_url=body.careers_url,
notes=body.notes, hand_reason=body.hand_reason)
except jobs.sources.Conflict as exc:
raise HTTPException(409, str(exc)) from exc
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
return _one_company(store, company.key)
class CompanyPatch(BaseModel):
name: str | None = None
careers_url: str | None = None
notes: str | None = None
hand_reason: HandReason | None = None
@router.patch("/companies/{key}")
def edit_company(key: str, body: CompanyPatch, store: StoreDep) -> CompanyOut:
"""Change any of a company's name, careers link, notes and reason; a field
left out stays. The key never changes, and `name` only for a company
without a board: 409 for one with a subscription, shown or not (see
`jobs.sources.edit_company`)."""
fields = body.model_dump(exclude_unset=True)
if any(v is None for v in fields.values()):
raise HTTPException(422, "A field is left out, not null.")
try:
jobs.sources.edit_company(store, key, **fields)
except KeyError:
raise HTTPException(404, f"no such company: {key}") from None
except jobs.sources.Conflict as exc:
raise HTTPException(409, str(exc)) from exc
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
return _one_company(store, key)
@router.delete("/companies/{key}", status_code=204)
def remove_company(key: str, store: StoreDep) -> Response:
"""Delete a company and every agent's stance on it. 409 for one with a
board shown or with open roles; detach the board first."""
try:
jobs.sources.remove_company(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 Response(status_code=204)
class CompanyBoardBody(BaseModel):
board: str
@@ -489,10 +567,12 @@ class CareersBody(BaseModel):
@router.post("/companies/{key}/careers")
def set_careers_url(key: str, body: CareersBody, store: StoreDep) -> Company:
"""Set or correct where a company's careers page is; "" clears it. 422
for anything but an http(s) URL, 404 for an unknown key."""
url = body.careers_url.strip()
if url and not url.lower().startswith(("http://", "https://")):
raise HTTPException(422, "careers_url must start with http:// or https://")
for anything but an http(s) URL (`jobs.sources.check_careers_url`, the
rule the by-hand edit shares), 404 for an unknown key."""
try:
url = jobs.sources.check_careers_url(body.careers_url)
except ValueError as exc:
raise HTTPException(422, str(exc)) from exc
try:
return store.update_company(key, careers_url=url)
except KeyError: