Tyler Munis Self Service Jobs API.

from urllib.parse import urlparse, parse_qs

HOSTED_DOMAIN = "munisselfservice.com"
SURFACES = ("ess", "mss")

def parse_munis(url: str) -> dict:
    parsed = urlparse(url)
    host = parsed.netloc.lower()
    parts = [p for p in parsed.path.strip("/").split("/") if p]

    surface = parts[0].lower() if parts and parts[0].lower() in SURFACES else ""
    if "EmploymentOpportunities" not in parsed.path:
        raise ValueError("not an EmploymentOpportunities route")

    query = {k.lower(): v[0] for k, v in parse_qs(parsed.query).items()}
    job = None
    if parsed.path.lower().endswith("jobdetail.aspx"):
        # The mutable 'desc' parameter is deliberately ignored.
        job = {"req": query.get("req"), "sreq": query.get("sreq"), "form": query.get("form")}
        if not all(job.values()):
            raise ValueError("JobDetail requires req, sreq and form")

    prefix = f"/{surface}" if surface else ""
    return {
        "tenant": host.split(".")[0] if host.endswith(HOSTED_DOMAIN) else host,
        "hosted": host.endswith(HOSTED_DOMAIN),
        "board_url": f"https://{host}{prefix}/EmploymentOpportunities/Default.aspx",
        "job": job,
    }

print(parse_munis("https://arhsnc.munisselfservice.com/ess/EmploymentOpportunities"
                  "/JobDetail.aspx?req=2026541&sreq=1&form=GEN"))

import requests

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

def fetch(url: str) -> requests.Response:
    resp = session.get(url, timeout=30, cookies={"UseCookies": "1"})
    resp.raise_for_status()
    return resp

board = parse_munis("https://cityoftulsa.munisselfservice.com/EmploymentOpportunities/Default.aspx")
first = fetch(board["board_url"])
print(first.status_code, len(first.text))

import re
from bs4 import BeautifulSoup

def openings_count(html: str) -> int:
    soup = BeautifulSoup(html, "html.parser")
    label = (soup.select_one("[id$='openingsCountLabelBottom']")
             or soup.select_one("[id$='openingsCountLabelTop']"))
    if label is None:
        raise RuntimeError("Munis board omitted its openings count — not a board page")

    digits = re.search(r"\d+", label.get_text())
    if not digits:
        raise RuntimeError("openings label carried no number")
    return int(digits.group())

def card_count(html: str) -> int:
    return len(BeautifulSoup(html, "html.parser").select("table.employmentopportunity"))

declared = openings_count(first.text)
print(f"{declared} openings declared, {card_count(first.text)} rendered")

from urllib.parse import urlencode

def show_all_form(html: str) -> dict:
    soup = BeautifulSoup(html, "html.parser")
    form = {field["name"]: field.get("value", "")
            for field in soup.select("input[type='hidden'][name]")}

    if "__VIEWSTATE" not in form or "__EVENTVALIDATION" not in form:
        raise RuntimeError("board omitted its WebForms state — cannot page")

    # Find the rows-per-page select and ask for every row.
    for select in soup.select("select[name]"):
        options = [o.get_text(strip=True).lower() for o in select.select("option")]
        if "all" in options:
            form[select["name"]] = "All"
    return form

def complete_snapshot(board: dict, html: str) -> str:
    declared = openings_count(html)
    if card_count(html) >= declared:
        return html

    resp = session.post(
        board["board_url"],
        data=urlencode(show_all_form(html)),
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        cookies={"UseCookies": "1"},
        timeout=60,
    )
    resp.raise_for_status()

    if openings_count(resp.text) != declared or card_count(resp.text) != declared:
        raise RuntimeError("Munis returned a truncated board — refuse the snapshot")
    return resp.text

page = complete_snapshot(board, first.text)
print(card_count(page), "cards after show-all")

import time

UNAVAILABLE = re.compile(r"Sorry,\s*this Employment Opp+ortunity is currently unavailable",
                         re.IGNORECASE)

def hydrate(board: dict, job: dict) -> dict | None:
    url = (board["board_url"].replace("Default.aspx", "JobDetail.aspx")
           + f"?req={job['req']}&sreq={job['sreq']}&form={job['form']}")
    resp = session.get(url, timeout=30, cookies={"UseCookies": "1"})
    if resp.status_code in (404, 410):
        return None                          # canonical removal
    resp.raise_for_status()
    if UNAVAILABLE.search(resp.text):
        return None                          # structured removal

    soup = BeautifulSoup(resp.text, "html.parser")
    card = soup.select_one("tcw-card.jobDetailCard") or soup.select_one(".jobDetailCard")
    if card is None:
        raise RuntimeError("neither a job card nor the unavailable page — parse failure")

    fields = {}
    for paragraph in card.select("p"):
        label = paragraph.select_one("b")
        if label:
            key = label.get_text(strip=True).rstrip(":").strip()
            fields[key] = paragraph.get_text(" ", strip=True)[len(key) + 1:].strip()

    return {
        "req": job["req"], "sreq": job["sreq"], "form": job["form"],
        "title": (card.select_one("h2") or card).get_text(strip=True),
        "description_html": card.decode_contents(),
        "fields": fields,
        "listing_url": url,
    }

for card in BeautifulSoup(page, "html.parser").select("table.employmentopportunity")[:3]:
    anchor = card.select_one("a[href*='JobDetail.aspx' i]")
    if anchor:
        print(bool(hydrate(board, parse_munis(anchor['href'])["job"])))
    time.sleep(0.25)