Read Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee and
Personio boards The `ats` plugin: one Source per host's public JSON (Personio: XML), each parsed to a common row and yielded as a `role` item. The field map, the redirect allow-list, the 8 MB cap and the 10 s timeout are ported from jobhunt-hq's openings.go (MIT); the nine-function classifier is ported from its seedgen. Workable, SmartRecruiters, Recruitee and Personio are new, written from one real board of each fetched while this was built. Fixtures under tests/fixtures/ats/ keep every test off the network. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
1 parent
ac5eca874a
commit
21ed472a87
10 files changed
+909
No files matched your search
@@ -0,0 +1,8 @@
|
||||
"""Drop-in plugins, discovered by `plugin_paths` in `roles.yaml`.
|
||||
|
||||
A plugin file imports `desk` only — see `tests/test_architecture.py`. This
|
||||
`__init__.py` makes the directory importable as `plugins.<name>` for the rest
|
||||
of roledesk (`jobs/pull.py`, `cli.py`, the tests), which the plugin contract
|
||||
itself never relies on: `desk.sources.registry` finds `ats.py` by path, not
|
||||
by this package.
|
||||
"""
|
||||
+548
@@ -0,0 +1,548 @@
|
||||
"""ATS boards: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio.
|
||||
|
||||
Every one of these hosts is a company's own careers page speaking public,
|
||||
unauthenticated JSON (Personio: XML) — first-party, no scraping, and a role
|
||||
that drops off the board is *closed*, which is the cheapest staleness check
|
||||
there is.
|
||||
|
||||
The field map, the redirect allow-list, the 8 MB body cap and the 10 s
|
||||
timeout are ported from `openings.go` and `cmd/seedgen/main.go` in
|
||||
[jobhunt-hq](https://github.com/rembrandtreyes/jobhunt-hq) (MIT), including
|
||||
`classify`'s nine functions and their keywords. Workable, SmartRecruiters,
|
||||
Recruitee and Personio are new: jobhunt-hq only read Greenhouse, Lever and
|
||||
Ashby, so those four are written from one real board of each host, fetched
|
||||
while this file was written (2026-09-23), rather than from the Go source.
|
||||
|
||||
A target is `host:slug`, e.g. `greenhouse:databricks`, `ashby:deepl`,
|
||||
`lever:acme`. Every board is fetched independently; one that fails or times
|
||||
out is logged and skipped, and the rest continue.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import html
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import xml.etree.ElementTree as ET
|
||||
from collections.abc import Callable, Iterator
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
|
||||
from desk.sources import (
|
||||
API_VERSION, ARTICLE_READER, Item, PluginSpec, Profile, Source,
|
||||
SummaryPolicy, TaggingPolicy, TargetSpec, Tasks, USER_AGENT, strip_html,
|
||||
)
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
#: Matches openings.go: a board answers in 10s or it is skipped, and its body
|
||||
#: is capped at 8 MB so a misbehaving host cannot hang a pull or fill memory.
|
||||
TIMEOUT = 10.0
|
||||
MAX_BYTES = 8 << 20
|
||||
|
||||
#: host -> (feed URL template, careers URL template). `{slug}` is filled in;
|
||||
#: recruitee and personio put the slug in the hostname instead of the path.
|
||||
_BOARDS: dict[str, tuple[str, str]] = {
|
||||
"greenhouse": ("https://boards-api.greenhouse.io/v1/boards/{slug}/jobs?content=true",
|
||||
"https://job-boards.greenhouse.io/{slug}"),
|
||||
"lever": ("https://api.lever.co/v0/postings/{slug}?mode=json",
|
||||
"https://jobs.lever.co/{slug}"),
|
||||
"ashby": ("https://api.ashbyhq.com/posting-api/job-board/{slug}",
|
||||
"https://jobs.ashbyhq.com/{slug}"),
|
||||
"workable": ("https://apply.workable.com/api/v3/accounts/{slug}/jobs",
|
||||
"https://apply.workable.com/{slug}"),
|
||||
"smartrecruiters": ("https://api.smartrecruiters.com/v1/companies/{slug}/postings",
|
||||
"https://jobs.smartrecruiters.com/{slug}"),
|
||||
"recruitee": ("https://{slug}.recruitee.com/api/offers/",
|
||||
"https://{slug}.recruitee.com"),
|
||||
"personio": ("https://{slug}.jobs.personio.de/xml",
|
||||
"https://{slug}.jobs.personio.de"),
|
||||
}
|
||||
|
||||
#: The hosts a request or a redirect may land on for a given board host — a
|
||||
#: fixed API host for five of them, and the company's own subdomain for the
|
||||
#: two that put the slug in the hostname. Anything else is refused, at the
|
||||
#: first hop and at every redirect: a feed is external content, and a board
|
||||
#: row must never be able to point this fetch at an internal address.
|
||||
def _allowed_host(host: str, slug: str) -> Callable[[str], bool]:
|
||||
fixed = {
|
||||
"greenhouse": "boards-api.greenhouse.io",
|
||||
"lever": "api.lever.co",
|
||||
"ashby": "api.ashbyhq.com",
|
||||
"workable": "apply.workable.com",
|
||||
"smartrecruiters": "api.smartrecruiters.com",
|
||||
}
|
||||
if host in fixed:
|
||||
want = fixed[host]
|
||||
return lambda h: h == want
|
||||
if host == "recruitee":
|
||||
want = f"{slug}.recruitee.com"
|
||||
return lambda h: h == want
|
||||
if host == "personio":
|
||||
want = f"{slug}.jobs.personio.de"
|
||||
return lambda h: h == want
|
||||
return lambda h: False
|
||||
|
||||
|
||||
def _is_web_url(url: str) -> bool:
|
||||
"""A trimmed http(s) URL, or refuse — a feed is external content and a
|
||||
`javascript:` or `data:` link must never reach an href. Port of
|
||||
openings.go's `webURL`."""
|
||||
url = (url or "").strip()
|
||||
if not url:
|
||||
return False
|
||||
parsed = httpx.URL(url)
|
||||
return parsed.scheme in ("http", "https") and bool(parsed.host)
|
||||
|
||||
|
||||
class _Refused(Exception):
|
||||
"""A board answered somewhere its allow-list does not cover."""
|
||||
|
||||
|
||||
def _get(client: httpx.Client, url: str, host: str, slug: str, *,
|
||||
method: str = "GET") -> bytes:
|
||||
"""Fetch one board feed: https only, the host's own allow-list, at most
|
||||
three redirect hops each checked the same way, and the body cut off at
|
||||
`MAX_BYTES`. Port of openings.go's `fetchOne`/`feedCache.allow`."""
|
||||
allow = _allowed_host(host, slug)
|
||||
current = url
|
||||
for _hop in range(4):
|
||||
parsed = httpx.URL(current)
|
||||
if parsed.scheme != "https" or not allow(parsed.host):
|
||||
raise _Refused(f"{current} is not an allowed host for {host}")
|
||||
response = client.request(
|
||||
method, current, timeout=TIMEOUT, follow_redirects=False,
|
||||
headers={"User-Agent": USER_AGENT, "Accept": "application/json, text/xml"},
|
||||
json={} if method == "POST" else None,
|
||||
)
|
||||
if response.is_redirect:
|
||||
location = response.headers.get("location") or ""
|
||||
if not location:
|
||||
raise ValueError("redirect with no location")
|
||||
current = str(httpx.URL(current).join(location))
|
||||
continue
|
||||
response.raise_for_status()
|
||||
body = response.content
|
||||
if len(body) > MAX_BYTES:
|
||||
raise ValueError(f"response too large ({len(body)} bytes)")
|
||||
return body
|
||||
raise ValueError("too many redirects")
|
||||
|
||||
|
||||
def _parse_dt(value: Any) -> datetime | None:
|
||||
"""An aware datetime from whatever a board sends: ISO-8601 with an
|
||||
offset, `Z`, a bare date, epoch milliseconds, or "YYYY-MM-DD HH:MM:SS
|
||||
UTC". None for anything else, which `Item` reads as "now"."""
|
||||
if value is None:
|
||||
return None
|
||||
if isinstance(value, int | float):
|
||||
if value <= 0:
|
||||
return None
|
||||
seconds = value / 1000 if value > 10**12 else value
|
||||
return datetime.fromtimestamp(seconds, tz=UTC)
|
||||
text = str(value).strip()
|
||||
if not text:
|
||||
return None
|
||||
try:
|
||||
parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
match = re.match(r"^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})", text)
|
||||
if not match:
|
||||
return None
|
||||
parsed = datetime.fromisoformat(f"{match.group(1)}T{match.group(2)}+00:00")
|
||||
return parsed if parsed.utcoffset() is not None else parsed.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
# ------------------------------------------------------------- the parsers
|
||||
|
||||
#: What every parser turns a feed into: one dict per row, with these keys.
|
||||
Row = dict[str, Any]
|
||||
|
||||
|
||||
def _parse_greenhouse(body: bytes) -> list[Row]:
|
||||
data = json.loads(body)
|
||||
rows = []
|
||||
for j in data.get("jobs") or []:
|
||||
title = (j.get("title") or "").strip()
|
||||
url = (j.get("absolute_url") or "").strip()
|
||||
if not title or not _is_web_url(url):
|
||||
continue
|
||||
departments = j.get("departments") or []
|
||||
# Greenhouse ships the description HTML-entity-escaped inside the
|
||||
# JSON string (`<p>`), so it needs unescaping before the tags
|
||||
# themselves can be stripped.
|
||||
content = html.unescape(j.get("content") or "")
|
||||
rows.append({
|
||||
"source_id": str(j.get("id") or ""),
|
||||
"title": title,
|
||||
"location": ((j.get("location") or {}).get("name") or "").strip(),
|
||||
"url": url,
|
||||
"posted": _parse_dt(j.get("first_published") or j.get("updated_at")),
|
||||
"department": (departments[0].get("name") if departments else "") or "",
|
||||
"description": strip_html(content),
|
||||
"remote": None, # Greenhouse's feed does not say
|
||||
"salary": "",
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_lever(body: bytes) -> list[Row]:
|
||||
data = json.loads(body)
|
||||
if not isinstance(data, list):
|
||||
return []
|
||||
rows = []
|
||||
for j in data:
|
||||
title = (j.get("text") or "").strip()
|
||||
url = (j.get("hostedUrl") or "").strip()
|
||||
if not title or not _is_web_url(url):
|
||||
continue
|
||||
categories = j.get("categories") or {}
|
||||
description = j.get("description") or j.get("descriptionPlain") or ""
|
||||
rows.append({
|
||||
"source_id": str(j.get("id") or ""),
|
||||
"title": title,
|
||||
"location": (categories.get("location") or "").strip(),
|
||||
"url": url,
|
||||
"posted": _parse_dt(j.get("createdAt")),
|
||||
"department": (categories.get("department") or categories.get("team") or "").strip(),
|
||||
"description": strip_html(description),
|
||||
"remote": (j.get("workplaceType") or "").strip() or None,
|
||||
"salary": "",
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_ashby(body: bytes) -> list[Row]:
|
||||
data = json.loads(body)
|
||||
rows = []
|
||||
for j in data.get("jobs") or []:
|
||||
title = (j.get("title") or "").strip()
|
||||
url = (j.get("jobUrl") or j.get("applyUrl") or "").strip()
|
||||
if not title or not _is_web_url(url):
|
||||
continue
|
||||
description = j.get("descriptionHtml") or j.get("descriptionPlain") or ""
|
||||
compensation = j.get("compensation") or {}
|
||||
salary = (compensation.get("compensationTierSummary")
|
||||
or compensation.get("scrapeableCompensationSalarySummary") or "")
|
||||
rows.append({
|
||||
"source_id": str(j.get("id") or ""),
|
||||
"title": title,
|
||||
"location": (j.get("location") or "").strip(),
|
||||
"url": url,
|
||||
"posted": _parse_dt(j.get("publishedAt")),
|
||||
"department": (j.get("department") or j.get("team") or "").strip(),
|
||||
"description": strip_html(description),
|
||||
"remote": j.get("isRemote"),
|
||||
"salary": salary,
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_workable(body: bytes) -> list[Row]:
|
||||
"""https://apply.workable.com/api/v3/accounts/{slug}/jobs (POST, empty
|
||||
JSON body) -> `{"total": int, "results": [...]}`. The shape is confirmed
|
||||
live (2026-09-23); the fields are Workable's long-documented job object,
|
||||
since every slug this session tried on it happened to list nothing at
|
||||
the moment of fetching — see the plugin's docstring and the build report."""
|
||||
data = json.loads(body)
|
||||
rows = []
|
||||
for j in data.get("results") or []:
|
||||
title = (j.get("title") or "").strip()
|
||||
url = (j.get("url") or j.get("shortlink") or j.get("application_url") or "").strip()
|
||||
if not title or not _is_web_url(url):
|
||||
continue
|
||||
location = ", ".join(p for p in (j.get("city"), j.get("region"), j.get("country")) if p)
|
||||
description = " ".join(p for p in (
|
||||
j.get("description"), j.get("requirements"), j.get("benefits")) if p)
|
||||
rows.append({
|
||||
"source_id": str(j.get("id") or j.get("shortcode") or ""),
|
||||
"title": title,
|
||||
"location": location,
|
||||
"url": url,
|
||||
"posted": _parse_dt(j.get("published_on") or j.get("created_at")),
|
||||
"department": (j.get("department") or "").strip(),
|
||||
"description": strip_html(description),
|
||||
"remote": j.get("telecommute"),
|
||||
"salary": "",
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_smartrecruiters(body: bytes, slug: str) -> list[Row]:
|
||||
"""https://api.smartrecruiters.com/v1/companies/{slug}/postings ->
|
||||
`{"content": [...]}`. The list omits the job description (only the
|
||||
per-posting detail endpoint has it, and fetching one per row would be
|
||||
hundreds of extra requests per board), so `description` stays empty here."""
|
||||
data = json.loads(body)
|
||||
rows = []
|
||||
for j in data.get("content") or []:
|
||||
title = (j.get("name") or "").strip()
|
||||
job_id = str(j.get("id") or "")
|
||||
if not title or not job_id:
|
||||
continue
|
||||
location = j.get("location") or {}
|
||||
loc_text = (location.get("fullLocation")
|
||||
or ", ".join(p for p in (location.get("city"), location.get("country")) if p))
|
||||
rows.append({
|
||||
"source_id": job_id,
|
||||
"title": title,
|
||||
"location": (loc_text or "").strip(),
|
||||
"url": f"https://jobs.smartrecruiters.com/{slug}/{job_id}",
|
||||
"posted": _parse_dt(j.get("releasedDate")),
|
||||
"department": ((j.get("department") or {}).get("label") or "").strip(),
|
||||
"description": "",
|
||||
"remote": location.get("remote"),
|
||||
"salary": "",
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_recruitee(body: bytes) -> list[Row]:
|
||||
data = json.loads(body)
|
||||
rows = []
|
||||
for j in data.get("offers") or []:
|
||||
title = (j.get("title") or "").strip()
|
||||
url = (j.get("careers_url") or "").strip()
|
||||
if not title or not _is_web_url(url):
|
||||
continue
|
||||
salary = j.get("salary") or {}
|
||||
salary_text = ""
|
||||
if isinstance(salary, dict) and (salary.get("min") or salary.get("max")):
|
||||
bounds = "-".join(str(v) for v in (salary.get("min"), salary.get("max")) if v)
|
||||
salary_text = f"{bounds} {salary.get('currency') or ''}".strip()
|
||||
rows.append({
|
||||
"source_id": str(j.get("id") or ""),
|
||||
"title": title,
|
||||
"location": (j.get("location") or j.get("city") or "").strip(),
|
||||
"url": url,
|
||||
"posted": _parse_dt(j.get("published_at") or j.get("created_at")),
|
||||
"department": (j.get("department") or "").strip(),
|
||||
"description": strip_html(j.get("description") or ""),
|
||||
"remote": j.get("remote"),
|
||||
"salary": salary_text,
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def _parse_personio(body: bytes, slug: str) -> list[Row]:
|
||||
"""`{slug}.jobs.personio.de/xml` -> `<workzag-jobs><position>...`. No job
|
||||
URL in the feed itself; Personio's own page is `/job/{id}`, confirmed
|
||||
live against a real posting (2026-09-23)."""
|
||||
root = ET.fromstring(body)
|
||||
rows = []
|
||||
for position in root.findall("position"):
|
||||
job_id = (position.findtext("id") or "").strip()
|
||||
title = (position.findtext("name") or "").strip()
|
||||
if not job_id or not title:
|
||||
continue
|
||||
description = " ".join(
|
||||
(value.text or "") for value in position.findall("jobDescriptions/jobDescription/value"))
|
||||
rows.append({
|
||||
"source_id": job_id,
|
||||
"title": title,
|
||||
"location": (position.findtext("office") or "").strip(),
|
||||
"url": f"https://{slug}.jobs.personio.de/job/{job_id}",
|
||||
"posted": _parse_dt(position.findtext("createdAt")),
|
||||
"department": (position.findtext("department") or "").strip(),
|
||||
"description": strip_html(description),
|
||||
"remote": "remote" in (position.findtext("office") or "").lower() or None,
|
||||
"salary": "",
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
#: host -> parser. Every one takes the raw response body, plus the slug for
|
||||
#: the two hosts whose feed does not carry the URL or the company itself.
|
||||
_PARSERS: dict[str, Callable[..., list[Row]]] = {
|
||||
"greenhouse": lambda body, slug: _parse_greenhouse(body),
|
||||
"lever": lambda body, slug: _parse_lever(body),
|
||||
"ashby": lambda body, slug: _parse_ashby(body),
|
||||
"workable": lambda body, slug: _parse_workable(body),
|
||||
"smartrecruiters": _parse_smartrecruiters,
|
||||
"recruitee": lambda body, slug: _parse_recruitee(body),
|
||||
"personio": _parse_personio,
|
||||
}
|
||||
|
||||
|
||||
# --------------------------------------------------------- the classifier
|
||||
|
||||
#: The fixed set of functions, and the keyword rules that map a department
|
||||
#: (preferred) or a title to one of them. Ported verbatim, in order, from
|
||||
#: `cmd/seedgen/main.go`'s `rules` — first match wins, and "product" is
|
||||
#: genuinely listed twice: the first, narrower entry is checked before
|
||||
#: recruiting/design/marketing/support/sales/data, and the second, which also
|
||||
#: matches the bare word "product", is checked only after all of those, so a
|
||||
#: title like "Data Product Manager" keeps classifying as data/product by the
|
||||
#: same rule order the Go tool used.
|
||||
FUNCTIONS = ("engineering", "data", "product", "design", "sales", "marketing",
|
||||
"customer success/support", "recruiting/people", "finance/legal/ops")
|
||||
|
||||
_RULES: tuple[tuple[str, tuple[str, ...]], ...] = (
|
||||
("product", ("product manag", "product management", "product operations",
|
||||
"program manag", "technical program")),
|
||||
("recruiting/people", ("recruit", "talent", "people ops", "people &",
|
||||
"people team", "people operations", "human resources",
|
||||
" hr ", "hr ", "hrbp")),
|
||||
("design", ("design", "ux", "user experience", "creative")),
|
||||
("marketing", ("marketing", "growth", "content", "communications", "brand",
|
||||
"seo", "social media", "demand gen", "events")),
|
||||
("customer success/support", ("customer success", "customer support",
|
||||
"customer experience", "customer service",
|
||||
"support", "success", "implementation",
|
||||
"onboarding", "professional services",
|
||||
"solutions consult", "technical account",
|
||||
"customer engineer", "deployment")),
|
||||
("sales", ("sales", "account executive", "account manager", "account director",
|
||||
"business development", "bdr", "sdr", "revenue", "partnership",
|
||||
"go-to-market", "gtm", "solutions engineer", "solution engineer",
|
||||
"pre-sales", "presales", "channel")),
|
||||
("data", ("data", "analytics", "machine learning", "ml ", " ml",
|
||||
"applied science", "research scientist", "statistic")),
|
||||
("product", ("product manag", "product management", "program manag",
|
||||
"product operations", "technical program", "product")),
|
||||
("finance/legal/ops", ("finance", "financ", "accounting", "legal", "counsel",
|
||||
"compliance", "operations", "ops", "administrat",
|
||||
"office", "procurement", "strategy", "corporate",
|
||||
"facilities", "risk", "audit", "tax", "treasury",
|
||||
"payroll", "executive assistant", "chief of staff",
|
||||
"workplace", "supply chain", "logistics", "fraud",
|
||||
"trust & safety", "trust and safety", "policy")),
|
||||
("engineering", ("engineer", "software", "developer", "infrastructure",
|
||||
"platform", "devops", "sre", "site reliability", "security",
|
||||
"information technology", " it", "it ", "technology",
|
||||
"technical staff", "hardware", "qa", "quality assurance",
|
||||
"architect", "research", "science", "scientist", "systems",
|
||||
"network", "cloud", "mobile", "frontend", "backend",
|
||||
"full stack", "fullstack", "web")),
|
||||
)
|
||||
|
||||
|
||||
def _classify_text(text: str) -> str:
|
||||
padded = f" {text.strip().lower()} "
|
||||
if not padded.strip():
|
||||
return ""
|
||||
for function, keywords in _RULES:
|
||||
if any(keyword in padded for keyword in keywords):
|
||||
return function
|
||||
return ""
|
||||
|
||||
|
||||
def classify(department: str, title: str) -> str:
|
||||
"""A department (preferred) or a title, to one of `FUNCTIONS`, or
|
||||
`"other"`. Port of seedgen's `classify`/`classifyText`."""
|
||||
return _classify_text(department or "") or _classify_text(title or "") or "other"
|
||||
|
||||
|
||||
def is_known_target(target: str) -> bool:
|
||||
"""`host:slug`, with `host` one of `_BOARDS` and a non-empty slug. What
|
||||
the target validator refuses: `roledesk companies add` and the pull job
|
||||
both call this before touching the network."""
|
||||
host, sep, slug = target.partition(":")
|
||||
return bool(sep) and host in _BOARDS and bool(slug.strip())
|
||||
|
||||
|
||||
def careers_url(target: str) -> str:
|
||||
"""The company's own careers page for `host:slug`, or "" for an unknown
|
||||
host. What `roledesk companies add` stores alongside the board."""
|
||||
host, _, slug = target.partition(":")
|
||||
if host not in _BOARDS:
|
||||
return ""
|
||||
return _BOARDS[host][1].format(slug=slug)
|
||||
|
||||
|
||||
def _fetch_rows(client: httpx.Client, target: str) -> list[Row]:
|
||||
"""One board, fetched and parsed. Raises on any failure — refused host,
|
||||
timeout, a feed shape none of the parsers understand."""
|
||||
if not is_known_target(target):
|
||||
raise ValueError(f"{target!r} is not host:slug for a known ATS host")
|
||||
host, _, slug = target.partition(":")
|
||||
url = _BOARDS[host][0].format(slug=slug)
|
||||
body = _get(client, url, host, slug, method="POST" if host == "workable" else "GET")
|
||||
return _PARSERS[host](body, slug)
|
||||
|
||||
|
||||
def fetch_board(target: str) -> list[Row]:
|
||||
"""Fetch and parse one board directly: no `Source`, no `self.state`, just
|
||||
"does this board answer, and what does it list". For `roledesk companies
|
||||
add|check`, which ask that question about one board at a time outside any
|
||||
pull. Raises the same way `_fetch_rows` does."""
|
||||
with httpx.Client() as client:
|
||||
return _fetch_rows(client, target)
|
||||
|
||||
|
||||
# -------------------------------------------------------------- the plugin
|
||||
|
||||
class ATSSource(Source):
|
||||
name = "ats"
|
||||
description = "Company job boards: Greenhouse, Lever, Ashby, Workable, " \
|
||||
"SmartRecruiters, Recruitee, Personio."
|
||||
#: The raw entries under `sources.ats.boards` are `{"url": target, "label":
|
||||
#: company}` — `url` carries the `host:slug` target and `label` the
|
||||
#: company name, which is how `Source.targets()`'s generic dict reading
|
||||
#: hands both back without a plugin-specific override.
|
||||
subscription_field = "boards"
|
||||
|
||||
spec = PluginSpec(
|
||||
api_version=API_VERSION, id=name, version="1", label="ATS boards",
|
||||
targets=TargetSpec(mode="editable", kind="board", defaults=[]),
|
||||
profiles={"default": Profile(
|
||||
kind="role",
|
||||
tasks=Tasks(
|
||||
summary=SummaryPolicy(enabled=False),
|
||||
tagging=TaggingPolicy(enabled=False),
|
||||
),
|
||||
presentation=ARTICLE_READER,
|
||||
)},
|
||||
)
|
||||
|
||||
def fetch(self) -> Iterator[Item]:
|
||||
client = httpx.Client()
|
||||
# Written by the pull job before any board is fetched (see
|
||||
# `roledesk/jobs/pull.py`); a plugin run on its own — a test, a dry
|
||||
# run — has no run to stamp itself against, so it makes one up.
|
||||
run_marker = self.state.get("ats:run", "") or datetime.now(UTC).isoformat(
|
||||
timespec="seconds")
|
||||
|
||||
for target, label in self.targets():
|
||||
host, _, slug = target.partition(":")
|
||||
try:
|
||||
rows = _fetch_rows(client, target)
|
||||
except Exception as exc:
|
||||
log.warning("ats: %s failed (%s)", target, exc)
|
||||
continue
|
||||
|
||||
seen_ids = []
|
||||
for row in rows:
|
||||
# The compound id, matching `roles.source_id` — what
|
||||
# `Store.mark_closed` compares against, not the board's own
|
||||
# bare job id.
|
||||
compound_id = f"{host}:{slug}:{row['source_id']}"
|
||||
seen_ids.append(compound_id)
|
||||
yield Item(
|
||||
source_id=compound_id,
|
||||
location=row["url"],
|
||||
title=row["title"],
|
||||
excerpt=(row["description"] or "")[:300],
|
||||
body=row["description"],
|
||||
published_at=row["posted"],
|
||||
subscription=label,
|
||||
kind="role",
|
||||
raw={
|
||||
"company": label,
|
||||
"place": row["location"],
|
||||
"department": row["department"],
|
||||
"function": classify(row["department"], row["title"]),
|
||||
"remote": row["remote"],
|
||||
"salary": row["salary"],
|
||||
"board": host,
|
||||
"slug": slug,
|
||||
},
|
||||
)
|
||||
# Stamped only once the board has parsed without raising, so a
|
||||
# board that blew up half way through is neither marked ok nor
|
||||
# has a partial id list treated as the whole of it.
|
||||
self.state[f"ats:ok:{target}"] = run_marker
|
||||
self.state[f"ats:ids:{target}"] = json.dumps(seen_ids)
|
||||
Reference in new issue
Block a user