atsfill 0.0.4.dev19__tar.gz → 0.0.4.dev21__tar.gz

{atsfill-0.0.4.dev19 → atsfill-0.0.4.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.4.dev19
+Version: 0.0.4.dev21
 Summary: Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle.
 Keywords: job-applications,ats,ashby,greenhouse,teamtailor,ai-agents,cli
 Author: shbernal
@@ -53,7 +53,7 @@ It is built for agents with a shell: every command prints one JSON document and
 ## Supported hiring systems
 
 <!-- badges -->
-![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
+![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
 <!-- /badges -->
 
 | System | Account needed | `read` without a browser |

{atsfill-0.0.4.dev19 → atsfill-0.0.4.dev21}/README.md

@@ -29,7 +29,7 @@ It is built for agents with a shell: every command prints one JSON document and
 ## Supported hiring systems
 
 <!-- badges -->
-![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
+![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
 <!-- /badges -->
 
 | System | Account needed | `read` without a browser |

{atsfill-0.0.4.dev19 → atsfill-0.0.4.dev21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev19"
+version = "0.0.4.dev21"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

{atsfill-0.0.4.dev19 → atsfill-0.0.4.dev21}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev19"
+version = "0.0.4.dev21"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

atsfill-0.0.4.dev21/src/atsfill/adapters/__init__.py

@@ -0,0 +1,16 @@
+from atsfill.adapters.ashby import Ashby
+from atsfill.adapters.greenhouse import Greenhouse
+from atsfill.adapters.oracle import Oracle
+from atsfill.adapters.smartrecruiters import SmartRecruiters
+from atsfill.adapters.teamtailor import Teamtailor
+from atsfill.adapters.wttj import WelcomeToTheJungle
+from atsfill.core.adapter import Adapter
+
+ADAPTERS: list[Adapter] = [
+    Ashby(),
+    Teamtailor(),
+    Greenhouse(),
+    WelcomeToTheJungle(),
+    SmartRecruiters(),
+    Oracle(),
+]

atsfill-0.0.4.dev21/src/atsfill/adapters/oracle.py

@@ -0,0 +1,628 @@
+"""Oracle Recruiting Cloud's Candidate Experience (`*.oraclecloud.com/hcmUI/CandidateExperience`),
+as docs/adapters/oracle.md observes.
+
+The form opens only past an email step, and an email the employer's Oracle already knows gets an
+emailed code instead. Reading passes the step with a throwaway address; filling starts over with
+the answer's. Oracle keeps a draft of the application from then on, autosaved as fields change.
+"""
+
+import re
+import uuid
+from contextlib import suppress
+from dataclasses import replace
+from datetime import date
+from pathlib import PurePath
+from typing import Any
+from urllib.parse import urlsplit
+
+from atsfill.core import browser, matching
+from atsfill.core.adapter import Blocked, Unsupported
+from atsfill.core.browser import Locator, Page
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+JOB = re.compile(r"/hcmUI/CandidateExperience/[\w-]+/sites/[^/]+/job/(\d+)")
+EMAIL = "email"
+LEGAL = "legalDisclaimer"
+COUNTRY = "country"
+EMAIL_INPUT = "input[type=email]"
+LEGAL_BOX = "legal-disclaimer .apply-flow-input-checkbox__button"
+NEXT = "button[type=submit].apply-flow-pagination__button"
+SUBMIT = ".apply-flow-pagination__submit-button"
+PAGINATION = ".apply-flow-pagination__button"
+PAGE_NUMBERS = ".apply-flow-navigation-pages__link:visible"
+LOADING = ".app-loading-spinner, .cx-select--loading, .apply-flow-block .skeleton"
+CODE_PAGE = ".apply-flow-pin-code-required"
+CAPTCHA = "iframe[src*='hcaptcha.com']"
+MANUALLY = ".quick-apply-flow__manually--link:visible"  # past an offer to import a profile
+COOKIES = ".cookie-consent button:visible"
+ATTACHED = ".attachment-upload-button__download, .misc-attachment-list__item-name"
+STEP_TIMEOUT_MS = 30_000
+LIST_TIMEOUT_MS = 3_000
+SETTLE_MS = 1_500
+UPLOAD_TIMEOUT_MS = 30_000
+CHECKBOX = ["Yes", "No"]
+KINDS = {
+    "text": FieldType.TEXT,
+    "phone": FieldType.PHONE,
+    "date": FieldType.DATE,
+    "pills": FieldType.CHOICE,
+    "radios": FieldType.CHOICE,
+    "select": FieldType.CHOICE,
+    "check": FieldType.CHOICE,
+    "multipills": FieldType.MULTI_CHOICE,
+    "checks": FieldType.MULTI_CHOICE,
+    "file": FieldType.FILE,
+}
+
+# Every field of the form, by block. A row's id is its label's DOM id without the counter Oracle
+# appends on each load (`labelText-lastName-14` is `lastName`); a block of tiles to add
+# (education, experience, skills) is one `tiles` entry.
+_READ = """() => {
+  const text = e => (e?.textContent || "").replace(/\\s+/g, " ").trim().replace(/\\s*\\*$/, "");
+  const stable = s => s?.replace(/^labelText-/, "").replace(/-\\d+(-label)?$/, "");
+  const shown = e => !!e.getClientRects().length;
+  const fields = [];
+  const add = f => { if (f.id && !fields.some(g => g.id === f.id)) fields.push(f); };
+  for (const block of document.querySelectorAll("apply-flow-block")) {
+    const kind = [...(block.firstElementChild?.classList || [])]
+      .find(c => c.startsWith("apply-flow-block--"))?.slice(18);
+    const title = block.querySelector(".apply-flow-block__title");
+    const blockRequired = !!title?.classList.contains("apply-flow-block__title--required");
+    const blockId = `block:${block.dataset.scrollSpyId}`;
+    if (!shown(block) || kind === "profile-import") continue;
+    if (kind === "agreements") {
+      for (const box of block.querySelectorAll("input[type=checkbox]")) {
+        const label = box.closest("label") || block.querySelector(`label[for="${box.id}"]`);
+        const id = (box.id || label?.id || "").replace(/-checkbox(-label)?$/, "");
+        add({id, kind: "check", label: text(label), required: false});
+      }
+      continue;
+    }
+    const files = [...block.querySelectorAll("input[type=file]")];
+    for (const input of files) {
+      const button = input.closest("resume-upload-button, cover-letter-upload-button");
+      const id = button?.tagName === "RESUME-UPLOAD-BUTTON" ? "resume"
+        : button ? "coverLetter" : blockId;
+      const required = button
+        ? !!button.querySelector(".attachment-upload-button__drag-and-drop-label--required")
+        : blockRequired;
+      const filled = button?.querySelector(".attachment-upload-button__download");
+      add({id, kind: "file", label: button ? text(button.querySelector(
+             ".attachment-upload-button__label")) : text(title), required,
+           accept: input.accept ? input.accept.split(",").map(s => s.trim()) : null,
+           value: filled ? text(filled) : null});
+    }
+    const rows = [...block.querySelectorAll(".input-row")]
+      .filter(r => !r.querySelector(".input-row") && shown(r));
+    if (!rows.length && !files.length && block.querySelector(
+        ".apply-flow-profile-item-tile__new-tile, .apply-flow-profile-item-button--add")) {
+      add({id: blockId, kind: "tiles", label: text(title), required: blockRequired});
+      continue;
+    }
+    for (const row of rows) {
+      const label = row.querySelector(".input-row__label");
+      const named = row.querySelector("[id^=labelText-]");
+      const input = row.querySelector("input:not([type=hidden]), textarea");
+      let id = stable(named?.id || label?.getAttribute("for") || label?.id || input?.name);
+      const field = {id, label: text(row.querySelector(
+          ".input-row__linebreak, .input-row__label-text") || label),
+        required: !!label?.classList.contains("input-row__label--required")
+          || !!row.querySelector("[aria-required=true], [required]")};
+      const pills = sel => [...row.querySelectorAll(sel)].map(text);
+      if (row.querySelector(".phone-row")) {
+        field.kind = "phone";
+        field.value = row.querySelector("input[type=tel]").value;
+      } else if (row.matches(".datepicker-row")) {
+        field.kind = "date";
+      } else if (row.querySelector("ul[role=radiogroup]")) {
+        field.kind = "pills";
+        field.options = pills(".cx-select-pill-name");
+      } else if (row.querySelector(".cx-multi-select-pills")) {
+        field.kind = "multipills";
+        field.options = pills(".cx-select-pill-name");
+      } else if (row.querySelector("input[role=combobox]")) {
+        field.kind = "select";
+        field.value = row.querySelector("input[role=combobox]").value;
+        field.geo = row.matches(".geo-hierarchy-form-element");
+        field.search = !!row.closest(".address-form") && !field.geo;
+      } else if (row.querySelector("input.apply-flow-input-radio-control")) {
+        field.kind = "radios";
+        field.options = pills(".apply-flow-input-radio__label");
+      } else if (row.querySelector(".input-row__control-item input[type=checkbox]")) {
+        field.kind = "checks";
+        field.options = pills(".apply-flow-input-checkbox__label");
+      } else if (input?.matches("textarea, input.input-row__control") && !input.disabled) {
+        field.kind = input.type === "email" ? "email" : "text";
+        field.value = input.value;
+        field.maxLength = input.maxLength > 0 ? input.maxLength : null;
+      } else continue;
+      add(field);
+    }
+  }
+  return fields;
+}"""
+
+# Whether the form is loaded; a dropdown loads only once scrolled into view, so the first one
+# still loading is brought there.
+_SETTLED = """(loading) => {
+  const pending = [...document.querySelectorAll(loading)]
+    .find(e => e.getClientRects().length && getComputedStyle(e).visibility !== "hidden");
+  pending?.scrollIntoView({block: "center"});
+  return !pending
+  && [...document.querySelectorAll(".apply-flow-block--personal-information-address-v2")]
+    .every(block => {
+    const country = block.querySelector("address-form-v2 input[role=combobox]");
+    return country && country.value && block.querySelector(".address-form .input-row");
+  });
+}"""
+
+# The selector of the element naming a field's row, found by the read's id rule.
+_ROW = """(id) => {
+  const stable = s => s?.replace(/^labelText-/, "").replace(/-\\d+(-label)?$/, "");
+  for (const row of document.querySelectorAll(".input-row")) {
+    if (row.querySelector(".input-row")) continue;
+    const label = row.querySelector(".input-row__label");
+    const named = row.querySelector("[id^=labelText-]");
+    const input = row.querySelector("input:not([type=hidden]), textarea");
+    const rowId = stable(named?.id || label?.getAttribute("for") || label?.id || input?.name);
+    if (rowId !== id) continue;
+    if (named) return `[id='${named.id}']`;
+    if (label?.getAttribute("for")) return `label[for='${label.getAttribute("for")}']`;
+    if (label?.id) return `[id='${label.id}']`;
+    return `[name='${input.name}']`;
+  }
+  return null;
+}"""
+
+# What the form holds for each field id, in the same terms the read gives its options.
+_READ_BACK = """(ids) => {
+  const text = e => (e?.textContent || "").replace(/\\s+/g, " ").trim();
+  const stable = s => s?.replace(/^labelText-/, "").replace(/-\\d+(-label)?$/, "");
+  const out = {};
+  for (const row of document.querySelectorAll(".input-row")) {
+    if (row.querySelector(".input-row")) continue;
+    const label = row.querySelector(".input-row__label");
+    const named = row.querySelector("[id^=labelText-]");
+    const input = row.querySelector("input:not([type=hidden]), textarea");
+    const id = stable(named?.id || label?.getAttribute("for") || label?.id || input?.name);
+    const kind = ids[id];
+    if (id in out) continue;  // a field shown twice is read where it is filled, the first
+    const values = sel => [...row.querySelectorAll(sel)].map(text);
+    if (kind === "phone") {
+      out[id] = row.querySelector("input[role=combobox]").value
+        + row.querySelector("input[type=tel]").value;
+    } else if (kind === "date") {
+      out[id] = [...row.querySelectorAll("input[role=combobox]")].map(i => i.value);
+    } else if (kind === "pills") {
+      out[id] = values(".cx-select-pill-section--selected .cx-select-pill-name")[0] ?? null;
+    } else if (kind === "multipills") {
+      out[id] = values(".cx-select-pill-section--selected .cx-select-pill-name");
+    } else if (kind === "select" || kind === "typeahead") {
+      out[id] = row.querySelector("input[role=combobox]").value;
+    } else if (kind === "radios" || kind === "checks") {
+      const picked = [...row.querySelectorAll("input:checked")]
+        .map(i => text(row.querySelector(`label[for="${i.id}"]`)));
+      out[id] = kind === "radios" ? picked[0] ?? null : picked;
+    } else if (kind === "text" || kind === "email") {
+      out[id] = input.value;
+    }
+  }
+  for (const box of document.querySelectorAll("apply-flow-block input[type=checkbox]")) {
+    const label = box.closest("label") || document.querySelector(`label[for="${box.id}"]`);
+    const id = (box.id || label?.id || "").replace(/-checkbox(-label)?$/, "");
+    if (ids[id] === "check") out[id] = box.checked ? "Yes" : "No";
+  }
+  for (const [id, kind] of Object.entries(ids)) {
+    if (kind !== "file") continue;
+    const host = id === "resume" ? document.querySelector("resume-upload-button")
+      : id === "coverLetter" ? document.querySelector("cover-letter-upload-button")
+      : document.querySelector(`apply-flow-block[data-scroll-spy-id="${id.slice(6)}"]`);
+    const attached = ".attachment-upload-button__download, .misc-attachment-list__item-name";
+    out[id] = text(host?.querySelector(attached)) || null;
+  }
+  return out;
+}"""
+
+
+class Oracle:
+    name = "oracle"
+    side_effects = [
+        SideEffect(
+            "load",
+            "hiring_system",
+            "the email step starts a draft application in the employer's Oracle, under a"
+            " throwaway address to read the form and under the answer's to fill it",
+        ),
+        SideEffect("fill", "hiring_system", "Oracle autosaves the draft, files included"),
+        SideEffect("submit", "employer", "the application reaches the employer"),
+    ]
+
+    def __init__(self) -> None:
+        self._fields: dict[str, Field] = {}
+        self._kinds: dict[str, str] = {}
+        self._pages: dict[str, int] = {}  # field id: the page of the form it is on
+        self._picked: dict[str, str] = {}  # a geography field's id: the item picked in it
+        self._months: list[str] = []
+        self._job = ""
+        self._uploads: dict[str, str] = {}
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        return JOB.search(urlsplit(url).path) is not None
+
+    def posting(self, url: str) -> str:
+        parts = urlsplit(url)
+        match = JOB.search(parts.path)
+        assert match, url
+        return f"https://{parts.hostname}/hcmUI/CandidateExperience/job/{match[1]}"
+
+    def read_api(self, url: str) -> list[Field] | None:
+        return None  # the form's metadata is served only past the email step
+
+    def read_form(self, page: Page) -> list[Field]:
+        parts = urlsplit(page.url)
+        match = JOB.search(parts.path)
+        assert match, page.url  # detected on a job URL
+        self._job = f"{parts.scheme}://{parts.netloc}{parts.path[: match.end()]}"
+        legal = self._email_step(page)
+        fields = [Field(EMAIL, "Email Address", FieldType.TEXT, True)]
+        if legal:
+            fields.append(Field(LEGAL, legal, FieldType.CHOICE, True, CHECKBOX))
+        self._pass_email_step(
+            page, f"atsfill.read.{uuid.uuid4().hex[:12]}@example.com", bool(legal)
+        )
+        self._kinds, self._pages = {}, {}
+        # The page numbers move between pages without checking the page left.
+        for number in range(1, max(len(_page_numbers(page)), 1) + 1):
+            _go_to(page, number)
+            described = [
+                (raw, field)
+                for raw in page.evaluate(_READ)
+                if raw["id"] not in self._kinds and (field := self._described(page, raw))
+            ]
+            for raw, field in _geography(described):
+                self._kinds[field.id], self._pages[field.id] = raw["kind"], number
+                fields.append(field)
+        self._fields = {f.id: f for f in fields}
+        return fields
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        if LEGAL in self._fields and answers.get(LEGAL) != "Yes":
+            raise Unsupported("not_qualified: the form opens only once the terms are accepted")
+        page.context.clear_cookies()
+        page.goto(self._job + "/apply/email")
+        page.evaluate("() => { localStorage.clear(); sessionStorage.clear(); }")
+        self._email_step(page)
+        email = answers.get(EMAIL)
+        assert isinstance(email, str)  # required, so answered
+        self._pass_email_step(page, email, LEGAL in self._fields)
+        for number in sorted(set(self._pages.values())):
+            on_page = [i for i in answers if self._pages.get(i) == number]
+            if not on_page:
+                continue
+            _go_to(page, number)
+            if COUNTRY in on_page:  # the address below it follows the country's format
+                self._fill(page, COUNTRY, answers[COUNTRY])
+                _settle(page)
+            for field_id in [i for i in on_page if i != COUNTRY]:
+                self._fill(page, field_id, answers[field_id])
+        self._uploads = {
+            i: PurePath(a).name
+            for i, a in answers.items()
+            if self._fields[i].type is FieldType.FILE and isinstance(a, str)
+        }
+        self._wait_for_uploads(page)
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        values: dict[str, Any] = page.evaluate(_READ_BACK, self._kinds)
+        values[LEGAL] = "Yes"  # the form shows only once the terms were accepted
+        for field_id, kind in self._kinds.items():
+            value = values.get(field_id)
+            if kind == "date" and isinstance(value, list):
+                values[field_id] = self._date_value(value)
+            picked = self._picked.get(field_id)
+            if picked and value and picked != value and picked.split(",")[0].strip() == value:
+                values[field_id] = picked  # an item that shows only its first part once picked
+        return {k: v for k, v in values.items() if v not in (None, "", [])}
+
+    def submit(self, page: Page) -> str | None:
+        _go_to(page, len(_page_numbers(page)) or 1)
+        _click(page, page.locator(SUBMIT))
+        page.wait_for_url(lambda url: "/apply/" not in url, timeout=STEP_TIMEOUT_MS * 3)
+        return page.url
+
+    def _email_step(self, page: Page) -> str | None:
+        """Opens the email step; the terms' label when it asks for them to be accepted."""
+        page.goto(self._job + "/apply/email")
+        try:
+            page.locator(EMAIL_INPUT).wait_for(timeout=STEP_TIMEOUT_MS)
+        except browser.Timeout:
+            raise Unsupported("posting_gone: no email step on the apply page") from None
+        _settle(page)
+        terms = page.locator("legal-disclaimer .apply-flow-input-checkbox__label")
+        return _text(terms.first.inner_text()) if terms.count() else None
+
+    def _pass_email_step(self, page: Page, email: str, agree: bool) -> None:
+        page.locator(EMAIL_INPUT).fill(email)
+        if agree:
+            box = page.locator(LEGAL_BOX).first
+            if "--checked" not in (box.get_attribute("class") or ""):
+                _click(page, box)
+        _click(page, page.locator(NEXT).first)
+        opened = page.locator(f"apply-flow-block, {CODE_PAGE}, {MANUALLY}")
+        try:
+            opened.first.wait_for(timeout=STEP_TIMEOUT_MS)
+            if page.locator(MANUALLY).count():
+                _click(page, page.locator(MANUALLY).first)
+                page.locator("apply-flow-block").first.wait_for(timeout=STEP_TIMEOUT_MS)
+        except browser.Timeout:
+            if page.locator(CAPTCHA).count():
+                raise Blocked("captcha: the email step asks for an hCaptcha") from None
+            raise Unsupported("form_shape: the email step did not open the form") from None
+        if page.locator(CODE_PAGE).count():
+            raise Blocked(
+                f"emailed_code: {email} is known to this employer's Oracle, which emails it a"
+                " code before it shows the form"
+            )
+        page.locator(f"{PAGINATION}:visible").first.wait_for(timeout=STEP_TIMEOUT_MS)
+        _settle(page)
+
+    def _described(self, page: Page, raw: dict[str, Any]) -> Field | None:
+        """The field a raw description is, None for one atsfill leaves out."""
+        if raw["kind"] == "tiles":
+            if raw["required"]:
+                raise Unsupported(f"form_shape: {raw['label']!r} needs entries added")
+            return None
+        if raw["kind"] == "email":
+            self._kinds[EMAIL] = "email"
+            return None
+        if raw["kind"] == "select":
+            options = self._options(page, raw["id"])
+            raw["kind"] = "select" if options else "text" if raw["search"] else "typeahead"
+            raw["options"] = options or None
+        if raw["kind"] == "date":
+            self._months = self._date_options(page, raw["id"])
+        return _field(raw)
+
+    def _row(self, page: Page, field_id: str) -> Locator:
+        """The innermost row holding the field."""
+        selector = page.evaluate(_ROW, field_id)
+        if selector is None:
+            raise Unsupported(f"form_shape: {field_id} left the form while it was filled")
+        return page.locator(".input-row").filter(has=page.locator(selector)).last
+
+    def _options(self, page: Page, field_id: str) -> list[str]:
+        """A dropdown's options, from its list once opened; none when it lists only matches
+        for what is typed."""
+        box = self._row(page, field_id).locator("input[role=combobox]")
+        return _open_list(page, box)
+
+    def _date_options(self, page: Page, field_id: str) -> list[str]:
+        return _open_list(page, self._row(page, field_id).locator("input[role=combobox]").first)
+
+    def _date_value(self, parts: list[str]) -> str | None:
+        month, day, year = parts
+        if not (month in self._months and day.isdigit() and year.isdigit()):
+            return None
+        return date(int(year), self._months.index(month) + 1, int(day)).isoformat()
+
+    def _fill(self, page: Page, field_id: str, answer: Answer) -> None:
+        field, kind = self._fields[field_id], self._kinds[field_id]
+        if kind == "check":
+            box = page.locator(f"[id='{field_id}-checkbox'], [id='{field_id}-checkbox-label']")
+            host = box.first.locator("xpath=ancestor-or-self::*[.//input][1]")
+            checked = host.locator("input[type=checkbox]").first.is_checked()
+            if checked != (answer == "Yes"):
+                _click(page, host.locator(".apply-flow-input-checkbox__button").first)
+            return
+        if kind == "file":
+            assert isinstance(answer, str)
+            self._file_input(page, field_id).set_input_files(answer)
+            return
+        row = self._row(page, field_id)
+        match kind, answer:
+            case "text", str():
+                box = row.locator("input, textarea").first
+                box.fill(answer)
+                if box.get_attribute("role") == "combobox":  # an address search, left unpicked
+                    box.press("Escape")
+                box.blur()
+            case "pills" | "multipills", _:
+                for value in [answer] if isinstance(answer, str) else answer:
+                    pill = row.locator(".cx-select-pill-section").filter(
+                        has=page.locator(".cx-select-pill-name", has_text=_exact(value))
+                    )
+                    if "--selected" not in (pill.first.get_attribute("class") or ""):
+                        _click(page, pill.first)
+            case "radios" | "checks", _:
+                for value in [answer] if isinstance(answer, str) else answer:
+                    label = row.locator("label").filter(has_text=_exact(value)).first
+                    target = page.locator(f"[id='{label.get_attribute('for')}']")
+                    if not target.is_checked():
+                        _click(page, label)
+            case "select", str():
+                _choose(page, row.locator("input[role=combobox]"), answer, exact=True)
+                self._picked[field_id] = answer
+            case "typeahead", str():
+                _choose(page, row.locator("input[role=combobox]"), answer, field=field)
+            case "phone", str():
+                self._phone(page, row, answer)
+            case "date", str():
+                year, month, day = answer.split("-")
+                boxes = row.locator("input[role=combobox]")
+                _choose(page, boxes.nth(0), self._months[int(month) - 1], exact=True)
+                _choose(page, boxes.nth(1), str(int(day)), exact=True)
+                _choose(page, boxes.nth(2), year, exact=True)
+            case _:
+                raise Unsupported(f"form_shape: cannot fill {field_id}, a {kind}, with {answer!r}")
+
+    def _phone(self, page: Page, row: Locator, answer: str) -> None:
+        """Picks the country code the number starts with, the longest that fits, then types
+        the rest of the number."""
+        digits = re.sub(r"\D", "", answer)
+        code = row.locator("input[role=combobox]")
+        codes = sorted(
+            {m[1] for o in _open_list(page, code) if (m := re.search(r"\+(\d+)", o))},
+            key=len,
+            reverse=True,
+        )
+        prefix = next((c for c in codes if digits.startswith(c)), None)
+        if prefix is None:
+            raise Unsupported(f"form_shape: no country code for {answer!r}")
+        _choose(page, code, f"+{prefix}", code=True)
+        number = row.locator("input[type=tel]")
+        number.fill(digits[len(prefix) :])
+        number.blur()
+
+    def _file_input(self, page: Page, field_id: str) -> Locator:
+        return page.locator(f"{_upload(field_id)} input[type=file]").first
+
+    def _wait_for_uploads(self, page: Page) -> None:
+        for field_id, name in self._uploads.items():
+            selector = f"{_upload(field_id)} :is({ATTACHED})"
+            done = page.locator(selector, has_text=name)
+            try:
+                done.first.wait_for(timeout=UPLOAD_TIMEOUT_MS)
+            except browser.Timeout:
+                return  # the read-back shows what was kept
+
+
+def _click(page: Page, target: Locator) -> None:
+    """Clicks, once more after what came over the target: the app's loading spinner, the
+    cookie banner (declined), or a header fixed over the top of the page."""
+    try:
+        browser.click(target)
+    except browser.Covered as e:
+        if "cookie-consent" in str(e):
+            buttons = page.locator(COOKIES)
+            decline = buttons.filter(has_text=re.compile("decline|reject|necessary", re.I))
+            browser.click((decline if decline.count() else buttons).first)
+        elif "loading" in str(e):
+            _settle(page)
+        else:  # a header fixed over the top of the page
+            target.evaluate("e => e.scrollIntoView({block: 'center'})")
+        browser.click(target)
+
+
+def _geography(described: list[tuple[dict, Field]]) -> list[tuple[dict, Field]]:
+    """Leaves one field of the address's geography (state, city, postal code), the most
+    specific: its items name the levels above (`0200, Acton, ACT`), and picking one fills
+    them. It is required when any level is."""
+    levels = [(r, f) for r, f in described if r.get("geo") and f.id != COUNTRY]
+    if len(levels) < 2 or not any(f.options for _, f in levels):
+        return described
+    parts = lambda f: max(len(o.split(",")) for o in f.options or [""])  # noqa: E731
+    kept = max(levels, key=lambda rf: parts(rf[1]))
+    required = any(f.required for _, f in levels)
+    return [
+        (r, replace(f, required=required) if (r, f) == kept else f)
+        for r, f in described
+        if (r, f) == kept or (r, f) not in levels
+    ]
+
+
+def _page_numbers(page: Page) -> list[str]:
+    """The page numbers of a form over several pages, none for a single page."""
+    return [_text(t) for t in page.locator(PAGE_NUMBERS).all_inner_texts() if _text(t).isdigit()]
+
+
+def _go_to(page: Page, number: int) -> None:
+    """Opens a page of the form by its number, clicked once more when the first click is lost
+    while the page settles."""
+    if not _page_numbers(page) or re.search(rf"/apply/section/{number}\b", page.url):
+        return
+    for _ in range(2):
+        _click(page, page.locator(PAGE_NUMBERS).filter(has_text=_exact(str(number))).first)
+        with suppress(browser.Timeout):
+            page.wait_for_url(
+                re.compile(rf"/apply/section/{number}\b"),
+                timeout=STEP_TIMEOUT_MS // 2,
+                wait_until="commit",
+            )
+            _settle(page)
+            return
+    raise Unsupported(f"form_shape: page {number} of the form did not open")
+
+
+def _upload(field_id: str) -> str:
+    """The element holding a file field's upload button."""
+    hosts = {"resume": "resume-upload-button", "coverLetter": "cover-letter-upload-button"}
+    return hosts.get(field_id) or f"apply-flow-block[data-scroll-spy-id='{field_id[6:]}']"
+
+
+def _text(value: str) -> str:
+    return re.sub(r"\s+", " ", value).replace("*", "").strip()
+
+
+def _exact(value: str) -> re.Pattern:
+    return re.compile(rf"^\s*{re.escape(value)}\s*$")
+
+
+def _settle(page: Page) -> None:
+    """Waits for the dropdowns to load, and the address block for its country's format."""
+    with suppress(browser.Timeout):
+        page.wait_for_function(_SETTLED, arg=LOADING, timeout=STEP_TIMEOUT_MS)
+    page.wait_for_timeout(SETTLE_MS)
+
+
+def _open_list(page: Page, box: Locator) -> list[str]:
+    """The items a dropdown lists once opened, then closed again."""
+    _click(page, box)
+    cells = page.locator(f"[id='{box.get_attribute('aria-controls')}'] [role=gridcell]")
+    try:
+        cells.first.wait_for(timeout=LIST_TIMEOUT_MS)
+        options = [_text(t) for t in cells.all_inner_texts()]
+    except browser.Timeout:
+        options = []
+    box.press("Escape")
+    return options
+
+
+def _choose(
+    page: Page,
+    box: Locator,
+    answer: str,
+    *,
+    exact: bool = False,
+    code: bool = False,
+    field: Field | None = None,
+) -> None:
+    """Types into a dropdown, which filters its list, and picks the item that is the answer
+    (or holds it as a phone code, or matches it as a suggestion). A list whose search does not match
+    its items' text as typed is looked through whole."""
+    for typed in (answer, ""):
+        _click(page, box)
+        box.fill("")
+        if typed:
+            box.press_sequentially(typed, delay=20)
+        cells = page.locator(f"[id='{box.get_attribute('aria-controls')}'] [role=gridcell]")
+        with suppress(browser.Timeout):
+            cells.first.wait_for(timeout=LIST_TIMEOUT_MS * 2)
+        for i in range(cells.count()):
+            item = _text(cells.nth(i).inner_text())
+            if (
+                (exact and item == answer)
+                or (code and re.search(rf"{re.escape(answer)}(\D|$)", item))
+                or (field is not None and matching.matches(field, answer, item))
+            ):
+                cells.nth(i).scroll_into_view_if_needed()
+                _click(page, cells.nth(i))
+                return
+        box.press("Escape")
+        if field is not None:
+            break  # a search lists nothing untyped
+    raise Unsupported(f"form_shape: no item for {answer!r} in a dropdown")
+
+
+def _field(raw: dict[str, Any]) -> Field:
+    kind = FieldType.TYPEAHEAD if raw["kind"] == "typeahead" else KINDS[raw["kind"]]
+    options = CHECKBOX if raw["kind"] == "check" else raw.get("options")
+    return Field(
+        raw["id"],
+        raw["label"],
+        kind,
+        raw["required"],
+        options,
+        raw.get("maxLength"),
+        raw.get("accept"),
+        prefilled=bool(raw.get("value")),
+    )

atsfill-0.0.4.dev21/src/atsfill/adapters/smartrecruiters.py

@@ -0,0 +1,408 @@
+"""SmartRecruiters (`jobs.smartrecruiters.com` job pages and their One Click apply form), as
+docs/adapters/smartrecruiters.md observes.
+
+The form is two pages: the profile, then the screening questions and consents. The second
+page's questions come from the page's own `__OC_CONTEXT__`, so `read_form` lists them without
+leaving the first page. Nothing but the resume reaches SmartRecruiters before submit, so the
+read-back is the page: the profile as it stood when `fill` left it, then the second page.
+"""
+
+import json
+import re
+from contextlib import suppress
+from typing import Any
+from urllib.parse import urlsplit
+
+from atsfill.core.adapter import Unsupported
+from atsfill.core.browser import Locator, Page, Timeout
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+HOSTS = ("jobs.smartrecruiters.com", "www.smartr.me")
+JOB = re.compile(r"^/([^/]+)/(\d+)")
+ONECLICK = re.compile(r"^/oneclick-ui/company/([^/]+)/publication/([^/]+)")
+APPLY_LINK = "a[href*='/oneclick-ui/company/']"
+QUESTIONS = "sr-screening-questions-form"
+CONTAINER = f"{QUESTIONS} [data-test=question-container]"
+FORM_TIMEOUT_MS = 30_000
+COOKIE_TIMEOUT_MS = 5_000
+OPTION_TIMEOUT_MS = 10_000
+UPLOAD_TIMEOUT_MS = 30_000
+SUBMIT_TIMEOUT_MS = 90_000
+NEXT_TIMEOUT_MS = 8_000
+NEXT_TRIES = 3
+YES_NO = ["Yes", "No"]
+
+# The profile page: (field id, the input, the element carrying `label` and `required`).
+PROFILE = [
+    ("first_name", "input#first-name-input", "spl-input#first-name-input"),
+    ("last_name", "input#last-name-input", "spl-input#last-name-input"),
+    ("email", "input#email-input", "spl-input#email-input"),
+    ("confirm_email", "input#confirm-email-input", "spl-input#confirm-email-input"),
+    ("location", "oc-location-autocomplete input", "oc-location-autocomplete spl-autocomplete"),
+    ("phone", "oc-phone-number input[type=tel]", "oc-phone-number spl-phone-field"),
+    ("linkedin", "input#linkedin-input", "spl-input#linkedin-input"),
+    ("facebook", "input#facebook-input", "spl-input#facebook-input"),
+    ("x", "input#twitter-input", "spl-input#twitter-input"),
+    ("website", "input#website-input", "spl-input#website-input"),
+    ("resume", "oc-resume-upload input[type=file]", "oc-resume-upload"),
+    (
+        "message",
+        "textarea#hiring-manager-message-input",
+        "spl-textarea#hiring-manager-message-input",
+    ),
+]
+PROFILE_TYPES = {
+    "location": FieldType.TYPEAHEAD,
+    "phone": FieldType.PHONE,
+    "resume": FieldType.FILE,
+}
+# Sections of the profile that take entries through their own sub-form.
+ENTRIES = ("oc-experience", "oc-education")
+# Screening question types: one field per entry of the question's `fields`.
+FIELD_TYPES = {
+    "text": FieldType.TEXT,
+    "textarea": FieldType.TEXT,
+    "radio": FieldType.CHOICE,
+    "select": FieldType.CHOICE,
+    "checkbox": FieldType.CHOICE,
+}
+SKIPPED = ("info",)  # text with no input
+OPTIONAL_ONLY = ("files", "languages")  # left out when optional, unsupported when required
+
+_CONTEXT = """() => {
+  const s = [...document.scripts].find(s => s.textContent.includes("__OC_CONTEXT__"));
+  if (!s) return null;
+  const t = s.textContent;
+  return JSON.parse(t.slice(t.indexOf("{"), t.lastIndexOf("}") + 1));
+}"""
+
+# Which question each container on the questions page holds, in page order. A text, select or
+# checkbox carries `question_<id>`; a radio group or an EEO pair does not, and is the next
+# question of its type: a hidden conditional question has no container.
+_CONTAINERS = """(form, questions) => {
+  const root = form.shadowRoot ?? form;
+  let at = 0;
+  return [...root.querySelectorAll("[data-test=question-container]")].map(box => {
+    const marked = box.querySelector("[id^=question_], [name^=question_]");
+    const mark = [marked?.id, marked?.getAttribute("name")].find(v => v?.startsWith("question_"));
+    const id = mark?.replace(/^question_/, "");
+    const FIELD = "SR-QUESTION-FIELD-";
+    const field = [...box.querySelectorAll("*")].find(e => e.tagName.startsWith(FIELD));
+    const type = field ? field.tagName.slice(FIELD.length).toLowerCase() : null;
+    const i = questions.findIndex((q, n) => n >= at && (id ? q.id === id : q.type === type));
+    if (i < 0) return null;
+    at = i + 1;
+    return questions[i].id;
+  });
+}"""
+
+
+class SmartRecruiters:
+    name = "smartrecruiters"
+    side_effects = [
+        SideEffect(
+            "upload", "hiring_system", "an attached resume is stored by SmartRecruiters at once"
+        ),
+        SideEffect("submit", "employer", "the application reaches the employer"),
+    ]
+
+    def __init__(self) -> None:
+        self._fields: dict[str, Field] = {}
+        self._questions: dict[str, dict[str, Any]] = {}  # by question id
+        self._conditions: list[dict[str, Any]] = []
+        self._consents: dict[str, str] = {}  # field id: the consent box's label
+        self._profile: dict[str, Answer] = {}  # the profile's read-back, taken before leaving it
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        return _key(url) is not None
+
+    def posting(self, url: str) -> str:
+        return _key(url) or url
+
+    def read_api(self, url: str) -> list[Field] | None:
+        return None  # the form's host answers 403 to anything but a browser
+
+    def read_form(self, page: Page) -> list[Field]:
+        if not ONECLICK.match(urlsplit(page.url).path):
+            link = page.locator(APPLY_LINK).first
+            try:
+                link.wait_for(state="attached", timeout=FORM_TIMEOUT_MS)
+            except Timeout:
+                raise Unsupported("posting_gone: no apply link on the job page") from None
+            page.goto(link.get_attribute("href") or "")
+        try:
+            page.locator(PROFILE[0][1]).wait_for(timeout=FORM_TIMEOUT_MS)
+        except Timeout:
+            raise Unsupported("posting_gone: no application form on the page") from None
+        _decline_cookies(page)
+        for section in ENTRIES:
+            if page.locator(f"{section} [data-test=section-required-mark]").count():
+                raise Unsupported(f"form_shape: {section.removeprefix('oc-')} entries are required")
+        context = page.evaluate(_CONTEXT) or {}
+        screening = context.get("screeningConfiguration") or {}
+        self._questions = {q["id"]: q for q in screening.get("questions") or []}
+        self._conditions = screening.get("conditionalConfigurations") or []
+        fields = [f for f in (_profile_field(page, *row) for row in PROFILE) if f]
+        for question in self._questions.values():
+            fields += self._question_fields(question)
+        self._consents = {}
+        for scope in (context.get("consent") or {}).get("consentScopeConfigs") or []:
+            if scope.get("checkboxRequired") is False:  # a notice with no box
+                continue
+            field_id = f"consent.{scope['scope']}"
+            self._consents[field_id] = _plain(scope["label"])
+            fields.append(Field(field_id, self._consents[field_id], FieldType.CHOICE,
+                                bool(scope.get("required")), YES_NO))  # fmt: skip
+        self._fields = {f.id: f for f in fields}
+        return fields
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        _decline_cookies(page)
+        for field_id, selector, _ in PROFILE:
+            if field_id in answers:
+                _fill_profile(page, field_id, selector, answers[field_id])
+        self._profile = _read_profile(page)
+        _next(page)
+        for question_id in self._questions:  # in page order: a trigger before its conditional
+            box = self._container(page, question_id)
+            if box is None:
+                continue
+            for field_id, field in self._question_answers(question_id):
+                if field_id in answers:
+                    _fill_question(box, self._questions[question_id], field, answers[field_id])
+        for field_id, box in self._consent_boxes(page).items():
+            if field_id in answers and box.is_checked() != (answers[field_id] == "Yes"):
+                box.click()
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        values: dict[str, Answer] = dict(self._profile)
+        for question_id, question in self._questions.items():
+            box = self._container(page, question_id)
+            if box is None:
+                continue
+            for field_id, field in self._question_answers(question_id):
+                if (value := _read_question(box, question, field)) is not None:
+                    values[field_id] = value
+        for field_id, box in self._consent_boxes(page).items():
+            values[field_id] = "Yes" if box.is_checked() else "No"
+        return {k: v for k, v in values.items() if v not in (None, "", [])}
+
+    def submit(self, page: Page) -> str | None:
+        before = page.url
+        page.get_by_role("button", name="Submit", exact=True).first.click()
+        page.wait_for_url(lambda url: url != before, timeout=SUBMIT_TIMEOUT_MS)
+        return page.url
+
+    def _question_fields(self, question: dict[str, Any]) -> list[Field]:
+        kind = question["type"]
+        if kind in SKIPPED or (kind in OPTIONAL_ONLY and not question["required"]):
+            return []
+        label = _plain(question["label"])
+        if condition := self._condition(question["id"]):
+            trigger = self._questions[condition["questionId"]]
+            picks = [v["label"] for f in trigger["fields"] for v in f["values"]
+                     if v["id"] in condition["fieldValues"]]  # fmt: skip
+            label += f" (asked when {_plain(trigger['label'])!r} is {' or '.join(picks)})"
+        fields = []
+        for entry in question["fields"]:
+            field_type = FIELD_TYPES.get(entry["type"])
+            if kind == "currency":
+                field_type = FieldType.TEXT
+            if field_type is None or kind in OPTIONAL_ONLY:
+                raise Unsupported(f"form_shape: {label!r} is a {kind} question")
+            options = [v["label"] for v in entry["values"]] or None
+            if kind == "checkbox":
+                options = YES_NO
+            elif entry.get("multipleChoice"):
+                field_type = FieldType.MULTI_CHOICE
+            many = len(question["fields"]) > 1
+            fields.append(Field(
+                f"{question['id']}.{entry['id']}" if many else question["id"],
+                f"{label}: {_plain(entry['label'])}" if many else label,
+                field_type,
+                bool(question["required"] and entry.get("required", True)) and not condition,
+                options,
+            ))  # fmt: skip
+        return fields
+
+    def _question_answers(self, question_id: str) -> list[tuple[str, dict[str, Any]]]:
+        """(field id, the question's field) for each field `read_form` listed."""
+        entries = self._questions[question_id]["fields"]
+        ids = [f"{question_id}.{e['id']}" if len(entries) > 1 else question_id for e in entries]
+        return [(i, e) for i, e in zip(ids, entries, strict=True) if i in self._fields]
+
+    def _condition(self, question_id: str) -> dict[str, Any] | None:
+        return next(
+            (c for c in self._conditions if question_id in c["conditionalQuestionIds"]), None
+        )
+
+    def _consent_boxes(self, page: Page) -> dict[str, Locator]:
+        """Each consent's box, in the order of the scopes: several open with a "Select all"."""
+        boxes = page.locator("oc-consent spl-checkbox input[type=checkbox]")
+        skip = boxes.count() - len(self._consents)
+        if skip not in (0, 1):
+            return {}
+        return {field_id: boxes.nth(skip + n) for n, field_id in enumerate(self._consents)}
+
+    def _container(self, page: Page, question_id: str) -> Locator | None:
+        form = page.locator(QUESTIONS)
+        if not form.count():
+            return None
+        held = form.first.evaluate(_CONTAINERS, list(self._questions.values()))
+        if question_id not in held:
+            return None
+        return page.locator(CONTAINER).nth(held.index(question_id))
+
+
+def _key(url: str) -> str | None:
+    """`https://jobs.smartrecruiters.com/<company>/<job id>`, or the One Click form's URL."""
+    parts = urlsplit(url)
+    if parts.hostname not in HOSTS:
+        return None
+    if match := ONECLICK.match(parts.path):
+        return f"https://jobs.smartrecruiters.com/oneclick-ui/company/{match[1]}/publication/{match[2]}"
+    if parts.hostname == HOSTS[0] and (match := JOB.match(parts.path)):
+        return f"https://jobs.smartrecruiters.com/{match[1]}/{match[2]}"
+    return None
+
+
+def _plain(text: str) -> str:
+    """A label without its markdown: links keep their text, emphasis marks go."""
+    text = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", text)
+    return re.sub(r"\s+", " ", text.replace("*", "")).strip()
+
+
+def _decline_cookies(page: Page) -> None:
+    reject = page.locator("#onetrust-reject-all-handler")
+    with suppress(Timeout):
+        reject.wait_for(state="visible", timeout=COOKIE_TIMEOUT_MS)
+        reject.click()
+
+
+def _profile_field(page: Page, field_id: str, selector: str, host: str) -> Field | None:
+    element = page.locator(host).first
+    if not page.locator(selector).count() or not element.count():
+        return None
+    if field_id == "resume":
+        label = element.locator("[data-test=section-title]").inner_text()
+        required = element.locator("[data-test=section-required-mark]").count() > 0
+        accept = page.locator(selector).first.get_attribute("accept") or ""
+        accepted = [a.strip() for a in accept.split(",") if a.strip()] or None
+        return Field(field_id, label.replace("*", "").strip(), FieldType.FILE, required, None,
+                     None, accepted)  # fmt: skip
+    label = element.get_attribute("label") or field_id.replace("_", " ").capitalize()
+    required = element.get_attribute("required") is not None
+    return Field(field_id, label, PROFILE_TYPES.get(field_id, FieldType.TEXT), required)
+
+
+def _fill_profile(page: Page, field_id: str, selector: str, answer: Answer) -> None:
+    value = answer if isinstance(answer, str) else answer[0]
+    target = page.locator(selector).first
+    match field_id:
+        case "resume":
+            target.set_input_files(value)
+            with suppress(Timeout):
+                page.locator("oc-resume-upload .c-spl-file-list-item-name").first.wait_for(
+                    timeout=UPLOAD_TIMEOUT_MS
+                )
+        case "location":  # takes one of its suggestions: the first for the typed text
+            target.click()
+            target.press_sequentially(value, delay=30)
+            options = page.locator("oc-location-autocomplete spl-select-option")
+            option = options.filter(has_text=re.compile(rf"^\s*{re.escape(value)}", re.I)).first
+            try:
+                option.wait_for(timeout=OPTION_TIMEOUT_MS)
+            except Timeout:  # another option would switch the field to a country and postal code
+                target.press("Escape")
+                return
+            option.click()
+        case "phone":  # the number's dial code picks the country
+            target.press_sequentially(value, delay=20)
+        case _:
+            target.fill(value)
+
+
+def _next(page: Page) -> None:
+    """Goes on to the questions page. Never Submit: a posting with no questions submits from
+    the profile page. A click right after the last answer can go unheeded, so it is repeated."""
+    button = page.get_by_role("button", name="Next", exact=True)
+    for _ in range(NEXT_TRIES):
+        if not button.count():
+            return
+        button.first.click()
+        with suppress(Timeout):
+            page.locator(QUESTIONS).first.wait_for(timeout=NEXT_TIMEOUT_MS)
+            return
+
+
+def _read_profile(page: Page) -> dict[str, Answer]:
+    values: dict[str, Answer] = {}
+    for field_id, selector, _ in PROFILE:
+        target = page.locator(selector).first
+        if not target.count():
+            continue
+        if field_id == "resume":
+            names = page.locator("oc-resume-upload .c-spl-file-list-item-name")
+            values[field_id] = names.first.inner_text().strip() if names.count() else ""
+        elif field_id == "phone":  # the field's value: {"internationalFormat": "+1…", …}
+            raw = page.locator("oc-phone-number spl-phone-field").first.get_attribute("value")
+            with suppress(ValueError, TypeError, AttributeError):
+                values[field_id] = json.loads(raw or "{}").get("internationalFormat") or ""
+        else:
+            values[field_id] = target.input_value()
+    return values
+
+
+def _option_ids(entry: dict[str, Any]) -> dict[str, str]:
+    return {v["label"]: v["id"] for v in entry["values"]}
+
+
+def _inputs(box: Locator, entry: dict[str, Any], question: dict[str, Any]) -> Locator:
+    """The input of one of the question's fields: an EEO pair holds one per field."""
+    n = [e["id"] for e in question["fields"]].index(entry["id"])
+    return box.locator("input:not([type=checkbox]), textarea").nth(n)
+
+
+def _fill_question(
+    box: Locator, question: dict[str, Any], entry: dict[str, Any], answer: Answer
+) -> None:
+    values = [answer] if isinstance(answer, str) else answer
+    match entry["type"]:
+        case "radio":
+            box.locator(f"spl-radio[value='{_option_ids(entry).get(values[0], '')}']").click()
+        case "checkbox":
+            target = box.locator("input[type=checkbox]").first
+            if target.is_checked() != (values[0] == "Yes"):
+                target.click()
+        case "select":
+            target = _inputs(box, entry, question)
+            for value in values:
+                option_id = _option_ids(entry).get(value)
+                if option_id is None:
+                    continue
+                target.click()
+                target.press_sequentially(value[:20], delay=20)
+                option = box.locator(f"spl-select-option[value='{option_id}']").first
+                try:
+                    option.wait_for(timeout=OPTION_TIMEOUT_MS)
+                except Timeout:
+                    target.press("Escape")
+                    continue
+                option.click()
+        case _:
+            _inputs(box, entry, question).fill(values[0])
+
+
+def _read_question(box: Locator, question: dict[str, Any], entry: dict[str, Any]) -> Answer | None:
+    match entry["type"]:
+        case "radio":
+            checked = box.locator("spl-radio[aria-checked=true]")
+            return checked.first.get_attribute("label") if checked.count() else None
+        case "checkbox":
+            return "Yes" if box.locator("input[type=checkbox]").first.is_checked() else "No"
+        case "select" if entry.get("multipleChoice"):  # the picked option ids, comma separated
+            picked = box.locator("spl-multiselect-autocomplete").first.get_attribute("value") or ""
+            labels = {v: k for k, v in _option_ids(entry).items()}
+            return [labels.get(i, i) for i in picked.split(",") if i]
+        case _:
+            return _inputs(box, entry, question).input_value()

{atsfill-0.0.4.dev19 → atsfill-0.0.4.dev21}/src/atsfill/registry.toml

@@ -70,14 +70,18 @@ kind = "ats"
 share = 0.0833
 account = "none"
 hosting = ["hosted"]
+adapter = "oracle"
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }
+dry_run_verified = { date = 2026-10-20, version = "0.0.3", by = "gate", commit = "1b67ce5" }
 
 [smartrecruiters]
 kind = "ats"
 share = 0.0441
 account = "none"
 hosting = ["hosted"]
+adapter = "smartrecruiters"
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }
+dry_run_verified = { date = 2026-10-20, version = "0.0.3", by = "gate", commit = "d7eb8e7" }
 
 [successfactors]
 kind = "ats"

atsfill-0.0.4.dev19/src/atsfill/adapters/__init__.py

@@ -1,7 +0,0 @@
-from atsfill.adapters.ashby import Ashby
-from atsfill.adapters.greenhouse import Greenhouse
-from atsfill.adapters.teamtailor import Teamtailor
-from atsfill.adapters.wttj import WelcomeToTheJungle
-from atsfill.core.adapter import Adapter
-
-ADAPTERS: list[Adapter] = [Ashby(), Teamtailor(), Greenhouse(), WelcomeToTheJungle()]