Ashby, BambooHR, Deel, Eightfold, Gem, Greenhouse, HiBob, HR Manager, Jibe, Jobylon and Lever move to feed_url(slug, ask) and page(get, slug, cursor, ask), declare READS with the robots decision, and drop robots_page. Rows carry places (Ashby secondaryLocations, Lever allLocations, Greenhouse offices in place of a Hybrid placeholder), Jobylon keeps its summary as teaser and maps experience and employment, Eightfold reads creationTs as the posting date and Ashby reads workplaceType. Fixtures <name>-places.* and jobylon-teaser.html drive the conformance checks; the eleven names leave UNDECLARED. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
182 lines
7.4 KiB
Python
182 lines
7.4 KiB
Python
"""Greenhouse: `greenhouse:<board token>`, the whole board in one JSON answer.
|
|
|
|
The field map is ported from `openings.go` in
|
|
[jobhunt-hq](https://github.com/rembrandtreyes/jobhunt-hq) (MIT).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import html
|
|
import json
|
|
import re
|
|
from collections.abc import Callable
|
|
from typing import Any
|
|
|
|
from desk.sources import strip_html
|
|
|
|
from ._contract import Ask, Fields, Place, Reads, Row
|
|
from ._shared import is_web_url, num, only, parse_dt, path_slug_ok, pay_line
|
|
|
|
NAME = "greenhouse"
|
|
LABEL = "Greenhouse"
|
|
RANK = 10
|
|
PATTERNS = (
|
|
r"(?:boards|job-boards|api)\.(?:eu\.)?greenhouse\.io/(?:v1/boards/|embed/job_board\?[^\"'\s]*for=)?([A-Za-z0-9_-]+)",
|
|
r"greenhouse\.io/embed/job_board/js\?for=([A-Za-z0-9_-]+)",
|
|
)
|
|
|
|
READS = Reads(
|
|
scope="board", listing="whole", text="listing", complete="whole",
|
|
places="many",
|
|
fields=Fields(pay="figures", posted="trusted"),
|
|
robots="api: no robots.txt check needed (public board API), 2026-09-30",
|
|
)
|
|
|
|
_API = "boards-api.greenhouse.io"
|
|
|
|
#: What a board writes as `location.name` when it means a way of working, not a
|
|
#: place (Cloudflare: "Hybrid", "In-Office", "Distributed; Hybrid"). The real
|
|
#: places are then in `offices`.
|
|
_PLACEHOLDER = re.compile(
|
|
r"(?:(?:hybrid|in[- ]?office|on[- ]?site|remote|distributed|flexible|office)"
|
|
r"(?:\s+or\s+|\s*[;/,&]\s*|\s+)?)+", re.I)
|
|
|
|
|
|
def slug_ok(slug: str) -> bool:
|
|
return path_slug_ok(slug)
|
|
|
|
|
|
def allowed(slug: str) -> Callable[[str], bool]:
|
|
return only(_API)
|
|
|
|
|
|
def careers_url(slug: str) -> str:
|
|
return f"https://job-boards.greenhouse.io/{slug}"
|
|
|
|
|
|
def feed_url(slug: str, ask: Ask) -> str:
|
|
return f"https://{_API}/v1/boards/{slug}/jobs?content=true&pay_transparency=true"
|
|
|
|
|
|
def fallback_url(slug: str) -> str:
|
|
"""The feed without `content=true`, read once when the full one exceeds
|
|
the byte cap: the descriptions are lost, but the titles land rather than
|
|
the whole board being skipped."""
|
|
return f"https://{_API}/v1/boards/{slug}/jobs"
|
|
|
|
|
|
def probe_url(slug: str) -> str:
|
|
return f"https://{_API}/v1/boards/{slug}"
|
|
|
|
|
|
def _salary(ranges: list[dict[str, Any]]) -> tuple[int | None, int | None, str]:
|
|
"""The yearly range from `pay_input_ranges` (needs `pay_transparency=true`
|
|
on the feed URL, see `feed_url`), which the list endpoint already carries
|
|
in the same request — no per-role fetch. Only when there is exactly one
|
|
range: a board with several ("Zone 1 Pay Range", "US Tier 2 Locations",
|
|
one per office) gives no way to tell which office the role in hand is
|
|
at, and picking one would misrepresent the columns. Greenhouse's own
|
|
ranges are cents, and yearly by convention except an hourly or a daily
|
|
one, named as such in `title` with no separate field to check — those
|
|
are skipped rather than annualised into a number nobody stated."""
|
|
if len(ranges) != 1:
|
|
return None, None, ""
|
|
entry = ranges[0]
|
|
title = str(entry.get("title") or "").lower()
|
|
if any(word in title for word in ("hour", "/hr", "daily", "per day", "day rate")):
|
|
return None, None, ""
|
|
code = str(entry.get("currency_type") or "").strip().upper()
|
|
if not code:
|
|
return None, None, ""
|
|
lo, hi = num(entry.get("min_cents")), num(entry.get("max_cents"))
|
|
if lo is None and hi is None:
|
|
return None, None, ""
|
|
return (int(lo / 100) if lo is not None else None,
|
|
int(hi / 100) if hi is not None else None, code)
|
|
|
|
|
|
def _salary_text(ranges: list[dict[str, Any]]) -> str:
|
|
"""One line per `pay_input_ranges` entry, joined with "; " — every range
|
|
Greenhouse states, not only the single one `_salary` accepts for the
|
|
columns. With more than one, each is labelled with the board's own
|
|
`title` ("Zone 1 Pay Range: ..."), since that is the only way to tell the
|
|
ranges apart; with just the one, the label adds nothing and is left off.
|
|
The hour/day check is the same one `_salary` uses to keep those out of
|
|
the yearly columns; here it only picks the word that follows "per"."""
|
|
multi = len(ranges) > 1
|
|
lines = []
|
|
for entry in ranges:
|
|
title = str(entry.get("title") or "").strip()
|
|
low_title = title.lower()
|
|
period = ("hour" if any(w in low_title for w in ("hour", "/hr"))
|
|
else "day" if "day" in low_title else "year")
|
|
lo, hi = num(entry.get("min_cents")), num(entry.get("max_cents"))
|
|
line = pay_line(lo / 100 if lo is not None else None,
|
|
hi / 100 if hi is not None else None,
|
|
entry.get("currency_type"), period)
|
|
if not line:
|
|
continue
|
|
if multi:
|
|
label = title.rstrip(":").strip() or "Range"
|
|
line = f"{label}: {line}"
|
|
lines.append(line)
|
|
return "; ".join(lines)
|
|
|
|
|
|
def _places(j: dict[str, Any]) -> list[Place]:
|
|
"""The role's places: each of `offices` (present with `content=true`), in
|
|
the host's words, or, when there is none, `location.name` as stated. A
|
|
`location.name` that only names a way of working ("Hybrid") is not a
|
|
place: the offices replace it."""
|
|
name = ((j.get("location") or {}).get("name") or "").strip()
|
|
out: list[Place] = []
|
|
for office in j.get("offices") or []:
|
|
text = str((office or {}).get("location") or (office or {}).get("name") or "").strip()
|
|
if text and text not in (p["text"] for p in out):
|
|
out.append({"text": text, "remote": True if re.search(r"\bremote\b", text, re.I)
|
|
else None})
|
|
if not out or not name or _PLACEHOLDER.fullmatch(name):
|
|
return out or ([{"text": name, "remote": True if re.search(r"\bremote\b", name, re.I)
|
|
else None}] if name else [])
|
|
# A name that says something the offices do not (a "Remote India" beside
|
|
# an office in Bangalore) is one more place; one they already contain,
|
|
# or that contains them, is the same place said twice.
|
|
low = name.lower()
|
|
if any(p["text"].lower() in low or low in p["text"].lower() for p in out):
|
|
return out
|
|
return [{"text": name, "remote": True if re.search(r"\bremote\b", name, re.I) else None}, *out]
|
|
|
|
|
|
def parse(body: bytes, slug: str) -> 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 "")
|
|
ranges = j.get("pay_input_ranges") or []
|
|
salary_min, salary_max, currency = _salary(ranges)
|
|
places = _places(j)
|
|
rows.append({
|
|
"source_id": str(j.get("id") or ""),
|
|
"title": title,
|
|
"places": places,
|
|
"location": "; ".join(p["text"] for p in places),
|
|
"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_text": _salary_text(ranges),
|
|
"salary_min": salary_min,
|
|
"salary_max": salary_max,
|
|
"currency": currency,
|
|
})
|
|
return rows
|