Keep a typed careers link, seed the by-hand reason and add the by-hand commands to app companies

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Sonnet 5.5 committed 2026-09-29 17:02:19 +02:00
1 parent a466ea52b7
commit b3cb93d5aa
3 files changed
+472 -15

No files matched your search

+121 -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,69 @@ 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."""
if store.company(key) is None:
print(f"companies checked: no company {key!r}", file=sys.stderr)
return 1
company = store.update_company(key, checked_at=store.now())
print(json.dumps({"key": key, "checked_at": company.checked_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 checked first and then the
longest ago, as the Sources page lists them; see `jobs.sources.by_hand`."""
from app import jobs
rows = jobs.sources.by_hand(store)
for c in rows:
checked = c.checked_at[:10] or "never"
print(f"{c.name:30} {c.hand_reason or '-':8} {checked: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."""
+120 -5
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
@@ -150,12 +151,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 checked first, then the longest ago; 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.checked_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
@@ -167,8 +272,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
@@ -186,8 +293,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:
@@ -200,13 +314,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}