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>
237 lines
9.1 KiB
Python
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
|