Files
jobboard/plugins/readers/jobylon.py
T
WolfandClaude Opus 5.5 c497fe965d Keep a description's headings, bullets and paragraphs, and draw them in the reader
The readers flattened a posting's HTML into one line with strip_html, so
sections and bullets ran together. _shared.html_text gives a line per
paragraph, '• ' before a list item and '## ' before a heading; every
reader's description goes through it, sections read per role get their
own headings, and the reader pane draws the lines as h3, ul and p.
Excerpts leave the marks out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 21:40:12 +02:00

237 lines
9.1 KiB
Python

"""Jobylon: `jobylon:<company id>`, the whole board in one HTML page, the
description on each role's own page.
Written from Einride's board (company 3143) and Vipps MobilePay's (1056, no
open roles) on 2026-09-29. Jobylon's own JSON and XML feeds are addressed by a
uuid the company sets and holds, and none is public for these two, so the
board is read from the widget's embed page, `cdn.jobylon.com/jobs/companies/
<id>/embed/v2/`, which assigns `JBL.embed_v2['jobs'] = [...]` as a JavaScript
literal with every open role (33 of 33 at Einride; `page_size` in the URL
the widget is embedded with only sets its client-side page). The literal has
unquoted keys and single-quoted strings, which `_json` reads. It carries no
description, so `detail` reads the role's page on emp.jobylon.com, whose
JSON-LD `JobPosting` has the description, the exact date and every location.
A slug Jobylon does not know answers 404.
"""
from __future__ import annotations
import html
import json
import logging
import re
from collections.abc import Callable
from typing import Any
from desk.sources import strip_html
from ._contract import Ask, Fields, Reads, Row
from ._shared import Get, html_text, parse_dt, place
log = logging.getLogger(__name__)
READS = Reads(
scope="board", listing="whole", text="detail", teaser=True, complete="whole",
places="many",
fields=Fields(posted="trusted", remote="stated", seniority="stated", employment="stated"),
robots=("read: robots.txt allows / for * and disallows /jobs/*/preview/, so "
"/jobs/companies/<id>/embed/v2/ on cdn.jobylon.com and /jobs/<id>-<name>/ on "
"emp.jobylon.com are allowed; it disallows / for named job crawlers (JobrapidoBot, "
"JoobleBot, AdzunaBot, ...), which this reader's agent is not (checked 2026-09-30)"),
)
NAME = "jobylon"
LABEL = "Jobylon"
PATTERNS = (
r"(?:emp|cdn)\.jobylon\.com/(?:jobs/)?companies/(\d+)",
# A company's own site says which board it embeds (careers.einride.tech
# sets `jbl_company_id = 3143`).
r"jbl_company_id[\"']?\s*[=:]\s*[\"']?(\d+)",
)
_CDN = "cdn.jobylon.com"
_EMP = "emp.jobylon.com"
#: A company id, matched whole. The host names are fixed, so a slug can only
#: ever land in a path.
_SLUG = re.compile(r"[0-9]{1,12}")
#: A role's page on the site, as the embed names it (`/jobs/385191-einride-
#: financial-controller/`): the only kind of link the module builds a URL
#: from.
_ROLE_PATH = re.compile(r"/jobs/[0-9]+(?:-[A-Za-z0-9_-]*)?/?")
_ASSIGNMENT = "JBL.embed_v2['jobs'] = "
_KEY = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
_TRAILING_COMMA = re.compile(r",(\s*[\]}])")
#: The English month names, by their first three letters, in the spellings
#: `published_date` uses ("Sept. 25, 2026").
_MONTHS = {m: i for i, m in enumerate(
("jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"), 1)}
_PUBLISHED = re.compile(r"([A-Za-z]{3})[A-Za-z]*\.? (\d{1,2}), (\d{4})")
def slug_ok(slug: str) -> bool:
return bool(_SLUG.fullmatch(slug))
def allowed(slug: str) -> Callable[[str], bool]:
return lambda host: host.lower() in (_CDN, _EMP)
def careers_url(slug: str) -> str:
"""Jobylon answers this with a redirect to `/companies/<id>-<name>/`."""
return f"https://{_EMP}/companies/{slug}/"
def feed_url(slug: str, ask: Ask) -> str:
"""Both hosts serve the same robots.txt (compared on 2026-09-29), so the
roles' pages on emp.jobylon.com are covered by what was checked for this
one."""
return f"https://{_CDN}/jobs/companies/{slug}/embed/v2/"
def _json(text: str) -> Any:
"""A JavaScript array or object literal as JSON: keys quoted, strings
single-quoted with `\\uXXXX` escapes, trailing commas."""
out: list[str] = []
i, n = 0, len(text)
while i < n:
char = text[i]
if char in "'\"":
i += 1
chars: list[str] = []
while i < n and text[i] != char:
if text[i] == "\\":
i += 1
if text[i] == "u":
chars.append(chr(int(text[i + 1:i + 5], 16)))
i += 4
elif text[i] == "x":
chars.append(chr(int(text[i + 1:i + 3], 16)))
i += 2
else:
chars.append({"n": "\n", "t": "\t", "r": "\r"}.get(text[i], text[i]))
else:
chars.append(text[i])
i += 1
i += 1
out.append(json.dumps("".join(chars)))
elif word := _KEY.match(text, i):
i = word.end()
colon = re.compile(r"\s*:").match(text, i)
out.append(json.dumps(word.group()) if colon else word.group())
else:
out.append(char)
i += 1
return json.loads(_TRAILING_COMMA.sub(r"\1", "".join(out)))
def _literal(body: bytes) -> str:
"""The text of the jobs array: from its `[` to the matching `]`, quotes
respected."""
text = body.decode("utf-8", "replace")
start = text.find(_ASSIGNMENT)
if start < 0:
raise ValueError("not a Jobylon board: no JBL.embed_v2['jobs'] in the page")
start += len(_ASSIGNMENT)
depth, i, quote = 0, start, ""
while i < len(text):
char = text[i]
if quote:
if char == "\\":
i += 1
elif char == quote:
quote = ""
elif char in "'\"":
quote = char
elif char == "[":
depth += 1
elif char == "]":
depth -= 1
if depth == 0:
return text[start:i + 1]
i += 1
raise ValueError("Jobylon's jobs array does not end")
def _published(value: Any) -> Any:
match = _PUBLISHED.fullmatch(str(value or "").strip())
month = _MONTHS.get(match.group(1).lower()) if match else None
if not match or not month:
return None
return parse_dt(f"{match.group(3)}-{month:02d}-{int(match.group(2)):02d}")
def parse(body: bytes, slug: str) -> list[Row]:
"""The embed page -> one row per role. `posted` is the day `published_date`
names, which `detail` replaces with the exact time. `location` joins the
names the embed lists, which can be fewer than the role's places
("Houston +3 more" lists three); `detail` has them all. The embed states
no pay. `department` is the role's `function`, unless it is the
placeholder "All functions"."""
out = []
for j in _json(_literal(body)):
title = (j.get("title") or "").strip()
job_id = str(j.get("id") or "").strip()
path = str(j.get("url") or "").strip()
if not title or not job_id or not _ROLE_PATH.fullmatch(path):
continue
function = str(j.get("function") or "").strip()
places = [place(name) for name in dict.fromkeys(
str(name).strip() for name in j.get("locations") or [] if str(name).strip())]
row: Row = {
"source_id": job_id,
"title": title,
"places": places,
"location": "; ".join(pl["text"] for pl in places),
"url": f"https://{_EMP}{path}",
"posted": _published(j.get("published_date")),
"department": "" if function == "All functions" else function,
"description": "",
"remote": str(j.get("workspace") or "").strip() or None,
"salary_text": "", # the embed states no pay
}
# `summary` is the text the company gave the listing, the string
# "None" when it gave none.
summary = " ".join(html.unescape(strip_html(str(j.get("summary") or ""))).split())
if summary and summary != "None":
row["teaser"] = summary
if seniority := str(j.get("experience") or "").strip():
row["seniority"] = seniority
if employment := str(j.get("employment_type") or "").strip():
row["employment"] = employment
out.append(row)
return out
def detail(get: Get, slug: str, row: Row) -> dict[str, Any]:
"""The role's own page: its JSON-LD `JobPosting` has the description, the
time it was posted and each place as "Houston, TX, USA"."""
page = get(row["url"], headers={"Accept": "text/html"}).decode("utf-8", "replace")
for block in re.findall(r'<script type="application/ld\+json"[^>]*>(.*?)</script>',
page, re.S):
try:
data = json.loads(block, strict=False)
except ValueError:
continue
if isinstance(data, dict) and data.get("@type") == "JobPosting":
break
else:
raise ValueError("no JobPosting on the role's page")
places = []
for loc in data.get("jobLocation") or []:
address = (loc or {}).get("address") or {}
name = str(address.get("streetAddress") or address.get("addressLocality") or "").strip()
if name and name not in places:
places.append(name)
found: dict[str, Any] = {
"description": html_text(data.get("description")),
"posted": parse_dt(data.get("datePosted")),
}
if places:
found["location"] = "; ".join(places)
found["places"] = [place(name) for name in places]
return found