Skyward FastTrack Jobs API.

from urllib.parse import urlparse, parse_qs

BOARD_PROGRAM = "rappljoblst484.w"
DETAIL_PROGRAM = "rappljoblst0502.w"
EXECUTABLES = {"wsisa.dll", "cgiip.exe"}

def parse_fasttrack(url: str) -> dict:
    parsed = urlparse(url)
    parts = [p for p in parsed.path.split("/") if p]
    # /scripts/{executable}/WService={service}/{program}
    if len(parts) < 4 or parts[0].lower() != "scripts":
        raise ValueError("not a FastTrack route")

    executable = parts[1].lower()
    if executable not in EXECUTABLES:
        raise ValueError(f"unknown WebSpeed executable {executable}")
    if not parts[2].startswith("WService="):
        raise ValueError("missing WService segment")

    return {
        # The authority includes a non-default port where the district uses one (444 is common).
        "authority": parsed.netloc,
        "executable": executable,
        # Case is significant: wsFin is not wsfin.
        "service": parts[2][len("WService="):],
        "program": parts[3],
        "record": (parse_qs(parsed.query).get("currentrecord") or [None])[0],
    }

print(parse_fasttrack(
    "https://bakerskyward.nefec.org/scripts/wsisa.dll/WService=wsFin/rappljoblst484.w"))

import json
import re
import requests
from bs4 import BeautifulSoup

ZD = re.compile(r"zD\[(?P<index>[0-9]+)\]\s*=\s*(?P<array>\[[^\r\n]*?\]);")
ZR = re.compile(r"var\s+zR\s*=\s*(?P<array>\[[^\r\n]*?\]);")

def board_url(authority: str, executable: str, service: str) -> str:
    return f"https://{authority}/scripts/{executable}/WService={service}/{BOARD_PROGRAM}"

session = requests.Session()
session.headers["Accept"] = "text/html,application/xhtml+xml"

board = parse_fasttrack(
    "https://finance.chisd.net/scripts/wsisa.dll/WService=wsFin/rappljoblst484.w")
resp = session.get(
    board_url(board["authority"], board["executable"], board["service"]),
    timeout=(4, 8),   # these are on-premises hosts; bound both connect and read
)
resp.raise_for_status()

columns = {int(m.group("index")): json.loads(m.group("array")) for m in ZD.finditer(resp.text)}
rowids = json.loads(ZR.search(resp.text).group("array"))
print(f"{len(columns)} columns, {len(rowids)} rowid slots")

def row_count(html: str) -> int:
    soup = BeautifulSoup(html, "html.parser")
    num_rows = soup.select_one("#numRows")
    displayed = soup.select_one("#dRecCount")
    if num_rows is None or displayed is None:
        raise RuntimeError("FastTrack browse page omitted its row accounting")

    declared = int(num_rows.get("value"))
    rendered = int("".join(ch for ch in displayed.get_text() if ch.isdigit()) or "-1")
    if declared != rendered:
        raise RuntimeError(f"count mismatch: numRows={declared}, dRecCount={rendered}")
    return declared

count = row_count(resp.text)
# zR is 1-based in the page's own JavaScript, so it carries count + 1 slots.
if any(len(values) != count for values in columns.values()) or len(rowids) != count + 1:
    raise RuntimeError("embedded arrays do not match the declared row count")
print(f"{count} vacancies, snapshot is complete")

def detail_url(board: dict, record: str) -> str:
    return (f"https://{board['authority']}/scripts/{board['executable']}"
            f"/WService={board['service']}/{DETAIL_PROGRAM}?currentrecord={record}")

def build_rows(board: dict, columns: dict, rowids: list, count: int) -> list[dict]:
    rows, rejected = [], 0
    for index in range(1, count + 1):
        record = rowids[index]
        if not isinstance(record, str) or not record.lower().startswith("0x"):
            rejected += 1
            continue
        rows.append({
            "record_id": record,
            "title": columns.get(0, [None] * count)[index - 1],
            "listing_url": detail_url(board, record),
        })
    if rejected:
        raise RuntimeError(f"{rejected} rows failed to parse — snapshot is incomplete")
    return rows

listings = build_rows(board, columns, rowids, count)
print(listings[:2])

import time

NATIVE_UNAVAILABLE = "The job listing record was not available."

def hydrate(board: dict, record: str) -> dict | None:
    url = detail_url(board, record)
    resp = session.get(url, timeout=(4, 8))
    if resp.status_code in (404, 410):
        return None                       # canonical HTTP removal
    resp.raise_for_status()
    if NATIVE_UNAVAILABLE.lower() in resp.text.lower():
        return None                       # structured removal
    page = BeautifulSoup(resp.text, "html.parser")

    echoed = page.select_one("input[name='currentrecord']")
    fieldset = page.select_one("fieldset#ListingData, fieldset[name='ListingData']")
    if echoed is None or fieldset is None or echoed.get("value", "").lower() != record.lower():
        # A generic page or a redirect is a failure, not an absence.
        raise RuntimeError("detail page did not round-trip the requested rowid")

    return {"record_id": record, "listing_url": url,
            "description_html": fieldset.decode_contents()}

for row in listings[:3]:
    print(bool(hydrate(board, row["record_id"])))
    time.sleep(0.25)