atsfill 0.0.8.dev219__tar.gz → 0.0.8.dev221__tar.gz

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.8.dev219
+Version: 0.0.8.dev221
 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

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.8.dev219"
+version = "0.0.8.dev221"
 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.8.dev219 → atsfill-0.0.8.dev221}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.8.dev219"
+version = "0.0.8.dev221"
 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.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/adp.py

@@ -49,6 +49,9 @@ NEXT = "#ja_sv_cw_next_footer_btn"
 PREVIOUS = "#ja_sv_cw_prev_footer_btn"
 SUBMIT = "#submitApplication"
 ATTEST = "input[name=self_att_agree_chk]"
+SIGNATURE = "attestation.signature"
+OPT_OUT = "resume.ai_opt_out"
+LATE = {SIGNATURE: OPTION_TIMEOUT_MS, OPT_OUT: UPLOAD_TIMEOUT_MS}  # boxes shown a moment after
 PERSON = "/jobApplication/applicant/person"
 PAY = "/jobApplication/requestedPayRate"
 
@@ -74,6 +77,7 @@ SHOWN_BY_COUNTRY = {"county"}  # once a country with counties is picked
 ADDRESS_MAX = 30  # "Address Line 1 must not exceed 30 characters"
 FIXED = {"personal.email"}  # the verified email, read only
 QUESTIONS = "#question_0, #questionYes_0, #desiredSalaryId, #refferalOptions, #commentTextArea"
+NOT_FIELDS = re.compile(r"select-filter-input|react-select-.*")  # a list's own inputs
 
 # Voluntary Self-ID: its lists and radio groups, each with the meta's indicator that shows it
 # and its code list; a radio's value is its code
@@ -113,6 +117,7 @@ class ADP:
         self._values: dict[str, Answer] = {}
         self._codes: dict[str, dict[str, str]] = {}  # a radio's label by its value, by field id
         self._amounts: set[str] = set()  # the page shows them formatted: `50,000.00`
+        self._shown: dict[str, None] = {}  # the fields each step showed, in order
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _posting(url) is not None
@@ -166,7 +171,7 @@ class ADP:
         asked = self._questions(control, transforms)
         self._steps = [
             Step("Personal Information", PERSONAL[0][1], self._personal(page, transforms)),
-            Step("Resume", "input[type=file]", [self._resume()]),
+            Step("Resume", "input[type=file]", [self._resume(), self._opt_out()]),
         ]  # fmt: skip
         # A wizard with nothing to ask has no Questions step; one that asks nothing the meta
         # lists has no box of its own: Next moves past it
@@ -176,25 +181,44 @@ class ADP:
             fields = self._self_id(transforms, indicators)
             self._steps.append(Step("Voluntary Self-ID", "#vsidWhy, #vsidEthRace", fields))
         self._steps.append(Step("Review Your Application", ""))
-        self._steps.append(Step("Self-Attest & Submit", SUBMIT, [self._attestation(control)]))
+        attest = [self._attestation(control), self._signature()]
+        self._steps.append(Step("Self-Attest & Submit", SUBMIT, attest))
         return [f for s in self._steps for f in s.fields]
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Answers each step and moves on with Next, up to the attestation, which it agrees to
         without Submit."""
-        self._values = {}
+        self._values, self._shown = {}, {}
         answers = {f.id: f.prefilled for s in self._steps for f in s.fields
                    if f.prefilled is not None} | answers  # fmt: skip
         for step in self._steps:
             _wait_for_step(page, step)
+            before = {key for key, _ in page.evaluate(_CONTROLS)}
             for f in step.fields:
                 if f.id in answers and f.id not in FIXED:
                     self._set(page, f, answers[f.id])
+            self._shown |= dict.fromkeys(self._shown_on(page, step, before))
             self._values |= self._read(page, step)
             if step.marker == SUBMIT:
                 return
             _next(page, step)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields each step showed once answered: the wizard holds one step at a time."""
+        return list(self._shown)
+
+    def _shown_on(self, page: Page, step: Step, before: set[str]) -> list[str]:
+        """The open step's fields: those with an enabled box, then the controls its answers
+        added that no field has. What it showed before them is not all fields, such as a
+        preferred name's box, so a control counts only as an answer's."""
+        boxes = {name for box in self._boxes.values() for name in re.findall(r"[\w-]+", box)}
+        shown = [f.id for f in step.fields if _enabled(page.locator(self._boxes[f.id]).first)]
+        for key, dom in page.evaluate(_CONTROLS):
+            listed = key in boxes or dom in boxes or NOT_FIELDS.fullmatch(key)
+            if key and key not in before and not listed:
+                shown.append(key)
+        return shown
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each step's values as it was left."""
         return dict(self._values)
@@ -246,6 +270,17 @@ class ADP:
         self._boxes["resume"] = "input[type=file]"
         return Field("resume", "Resume", FieldType.FILE, True, accept=[".pdf", ".doc", ".docx"])
 
+    def _opt_out(self) -> Field:
+        """The opt-out an employer's uploaded résumé shows, in no meta: listed on every form,
+        its box left alone unless answered."""
+        self._boxes[OPT_OUT] = "input[name=candidateProfileRelevanceOptionDivId]"
+        label = (
+            "I want to opt out from having my resume reviewed by artificial intelligence as "
+            "part of the application process."
+        )
+        return Field(OPT_OUT, label, FieldType.CHOICE, False, YES_NO, default="No",
+                     shown_when=Is("resume"))  # fmt: skip
+
     def _questions(self, control: dict[str, Any], transforms: dict[str, Any]) -> list[Field]:
         """The questionnaire, each question its `#question_<n>` by position; then the desired
         pay and the comment where the meta does not hide them."""
@@ -356,8 +391,17 @@ class ADP:
         self._boxes["attestation"] = ATTEST
         return Field("attestation", label, FieldType.CHOICE, True, YES_NO)
 
+    def _signature(self) -> Field:
+        """The name agreeing shows beneath the box, in no meta; the page's own words."""
+        self._boxes[SIGNATURE] = "#electronicSignature"
+        return Field(SIGNATURE, "Please type your full name.", FieldType.TEXT, True,
+                     shown_when=Is("attestation", ["Yes"]))  # fmt: skip
+
     def _set(self, page: Page, f: Field, answer: Answer) -> None:
         box = page.locator(self._boxes[f.id]).first
+        if f.id in LATE:
+            with suppress(Timeout):
+                box.wait_for(state="attached", timeout=LATE[f.id])
         if not box.count():
             return  # not shown: its condition is unmet
         if f.type is FieldType.FILE:
@@ -416,6 +460,10 @@ class ADP:
         return values
 
 
+# The open step's controls: what names each, and its id
+_CONTROLS = """() => [...document.querySelectorAll(
+  "input, textarea, select, sdf-select-simple, wfn-dropdown-list"
+)].map(e => [e.name || e.id, e.id])"""
 # The meta lists the questionnaire of the posting its header names
 _FETCH = """async ([url, requisition]) => {
   const headers = {requisitionoid: requisition, 'x-requested-with': 'XMLHttpRequest'};
@@ -520,6 +568,11 @@ def _label(page: Page, selector: str) -> str:
     return ""
 
 
+def _enabled(box: Locator) -> bool:
+    """A box the step shows and takes an answer in: race stays disabled until ethnicity allows."""
+    return box.count() > 0 and not box.evaluate("e => e.disabled === true")
+
+
 def _wait_for_step(page: Page, step: Step) -> None:
     if not step.marker:
         page.wait_for_timeout(SETTLE_MS)

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/adpmyjobs.py

@@ -95,6 +95,7 @@ class ADPMyJobs:
         self._codes: dict[str, dict[str, str]] = {}  # by field id: an option's label by code
         self._values: dict[str, Answer] = {}
         self._fixed: set[str] = set()  # disabled questions, their value shown as text
+        self._shown: dict[str, None] = {}  # the fields each page showed, in order
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _posting(url) is not None
@@ -202,7 +203,7 @@ class ADPMyJobs:
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Answers each section page by page, saving each with Next, up to the last section's
         last page, or its review."""
-        self._values = {}
+        self._values, self._shown = {}, {}
         answers = {f.id: f.prefilled for s in self._sections for f in s.fields
                    if f.prefilled is not None} | answers  # fmt: skip
         for section in self._sections:
@@ -210,9 +211,10 @@ class ADPMyJobs:
                 _on_section(page, section)
                 _to_page(page, section, ids)
                 _add_entries(page, section, number)
-                if unlisted := _unlisted(page, section):
-                    raise NotTaken(f"{section.title} shows {unlisted}, which the read did not list")
+                _all_listed(page, section)
                 self._answer(page, section, answers)
+                _all_listed(page, section)  # before a Next saves what the answers showed
+                self._shown |= dict.fromkeys(_shown_ids(page, section))
                 self._values |= self._read(page, section)
                 last = number == max(len(section.pages), 1) - 1
                 if section is self._sections[-1] and last and not section.review:
@@ -221,6 +223,10 @@ class ADPMyJobs:
             if section.review and section is not self._sections[-1]:
                 self._next(page, section)  # the review's Next saves the section
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields each page showed once answered: the workflow keeps one page at a time."""
+        return list(self._shown)
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each section's values as it was left."""
         return dict(self._values)
@@ -654,13 +660,24 @@ _SHOWN = """es => es
   .map(e => [e.dataset.name, e.querySelector('label')?.innerText.trim()])"""
 
 
-def _unlisted(page: Page, section: Section) -> str:
-    """The questions the open page shows that the read did not list, by label."""
+def _all_listed(page: Page, section: Section) -> None:
+    """Stops on a question the open page shows that the read did not list, before its Next
+    saves the section for good."""
     if section.component.startswith("prescreen"):
-        return ""
+        return
     listed = {f.id.removeprefix(f"{section.component}.") for f in section.fields}
     shown = page.locator("adp-form-group").evaluate_all(_SHOWN)
-    return ", ".join(repr(label or name) for name, label in shown if name not in listed)
+    unlisted = ", ".join(repr(label or name) for name, label in shown if name not in listed)
+    if unlisted:
+        raise NotTaken(f"{section.title} shows {unlisted}, which the read did not list")
+
+
+def _shown_ids(page: Page, section: Section) -> list[str]:
+    """The ids of the fields the open page shows; a prescreen's questions have no group."""
+    if section.component.startswith("prescreen"):
+        return [f.id for f in section.fields if _box(page, section, f).count()]
+    shown = page.locator("adp-form-group").evaluate_all(_SHOWN)
+    return [f"{section.component}.{name}" for name, _ in shown]
 
 
 def _on_section(page: Page, section: Section) -> None:

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/bamboohr.py

@@ -95,6 +95,9 @@ TYPES = {
     "file": FieldType.FILE,
 }
 
+CUSTOM_CONTROL = re.compile(r"customQuestionAnswers\.[a-z_]+?_(\d+)(_other)?")
+VETERAN_RADIOS = ("declineToAnswer", "notVeteran", "veteran")
+
 # The form's JSON answer and the state lists, fetched as the page fetches them.
 _FETCH = """async urls => {
   const out = [];
@@ -105,6 +108,12 @@ _FETCH = """async urls => {
   return out;
 }"""
 
+# Each control of the form: what names it, and whether a person sees it.
+_CONTROLS = """form => [...form.querySelectorAll("input, select, textarea")].map(e => ({
+  name: e.name, id: e.id, date: (e.placeholder ?? "").includes("yyyy"),
+  visible: e.offsetParent !== null,
+}))"""
+
 # What each present control shows, by the field's kind.
 _READ_BACK = """(form, specs) => {
   const named = name => form.querySelector(`[name="${name}"]`);
@@ -151,6 +160,7 @@ class BambooHR:
         # each field's (kind, control name, extra): a radio's option ids by text, the
         # veteran kinds' texts by id, a date's nothing
         self._specs: dict[str, tuple[str, str | None, Any]] = {}
+        self._on_read: set[str] = set()  # the controls' names as the form opened: its honeypot
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _job(url) is not None
@@ -208,6 +218,7 @@ class BambooHR:
         self._specs = {
             f.id: spec for f, (_, spec) in zip(out, fields, strict=True) if not f.unfillable
         }
+        self._on_read = {control["name"] for control in form.evaluate(_CONTROLS)}
         return out
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
@@ -266,6 +277,17 @@ class BambooHR:
                             continue  # its question was not answered Other
                     control.fill(value)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields the form holds a control for, once filled; a visible control that came
+        after the read and no field names, by its name."""
+        shown: dict[str, None] = {}
+        for control in page.locator(FORM).evaluate(_CONTROLS):
+            if field_id := _field_of(control):
+                shown[field_id] = None
+            elif control["visible"] and control["name"] not in self._on_read:
+                shown[control["name"]] = None
+        return [i for i in shown if i != "dateAvailable" or i in self._specs]
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         specs = {
             i: (kind, name, extra if kind == "veteran" else None)
@@ -307,6 +329,18 @@ class BambooHR:
         return f"{response.url} {response.status}"
 
 
+def _field_of(control: dict[str, Any]) -> str | None:
+    """The field a control belongs to: by its name, the date by its placeholder and the veteran
+    radios, whose name React makes up, by their ids."""
+    if control["date"]:
+        return "dateAvailable"
+    if control["id"] in VETERAN_RADIOS:
+        return "veteranStatusId"
+    if custom := CUSTOM_CONTROL.fullmatch(control["name"]):
+        return f"question_{custom[1]}{custom[2] or ''}"
+    return next((k for k, (_, name) in STANDARD.items() if name == control["name"]), None)
+
+
 def _job(url: str) -> tuple[str, str] | None:
     parts = urlsplit(url)
     if not (parts.hostname and HOST.match(parts.hostname)) or not (m := JOB.match(parts.path)):

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/eightfold.py

@@ -92,6 +92,9 @@ _DOM_IDS = """keys => {
   return out;
 }"""
 
+# The element ids of the controls on the page.
+_SHOWN = """() => [...document.querySelectorAll('[id$="_error"]')].map(e => e.id.slice(0, -6))"""
+
 _READ_BACK = """controls => {
   const out = {};
   for (const [qid, dom, kind] of controls) {
@@ -150,6 +153,7 @@ class Eightfold:
     def __init__(self) -> None:
         self._controls: list[_Control] = []  # in the form's order
         self._fields: list[Field] = []
+        self._ends: dict[str, str] = {}  # each question's id, by what its element id ends with
 
     def detect(self, url: str, page: Page | None) -> bool:
         if _pid(url) is None:
@@ -216,6 +220,7 @@ class Eightfold:
             if control.field.id in held and control.field.prefilled is None:
                 control.field = replace(control.field, default=held[control.field.id])
         self._fields = [c.field for c in self._controls]
+        self._ends = {end: c.field.id for c in self._controls for end in c.ends}
         self._controls = [c for c in self._controls if not c.field.unfillable]
         return self._fields
 
@@ -237,6 +242,15 @@ class Eightfold:
             _fill(page, control, answer)
             given[control.field.id] = answer
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The questions rendered once filled, each control's by the longest question id its
+        element id ends with; one no question's id ends as the page names it."""
+        shown: dict[str, None] = {}
+        for dom in page.evaluate(_SHOWN):
+            ends = [end for end in self._ends if dom == end or dom.endswith(f"_{end}")]
+            shown[self._ends[max(ends, key=len)] if ends else dom] = None
+        return list(shown)
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         unplaced = [[c.field.id, c.ends] for c in self._controls if c.dom is None]
         doms = page.evaluate(_DOM_IDS, unplaced) if unplaced else {}

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/gupy.py

@@ -9,12 +9,13 @@ information; the questions are saved by submit, for good.
 
 import re
 import time
+from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
 from atsfill.core.adapter import Blocked, Gap, NotTaken, Unsupported, known_gap
-from atsfill.core.browser import Locator, Page, Request, Response, Timeout
+from atsfill.core.browser import BrowserError, Locator, Page, Request, Response, Timeout
 from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = re.compile(r"^([a-z0-9-]+)\.gupy\.io$")
@@ -32,9 +33,26 @@ RESUME_WAIT_S = 15
 SAVE_TIMEOUT_MS = 30_000
 SIGN_IN_TIMEOUT_MS = 30_000
 FORMS_TIMEOUT_S = 10
+CLICK_ATTEMPTS = 3
 YES_NO = ["Yes", "No"]
+# What a Yes on an Additional information radio shows, the same on every posting, in no source a
+# read can see; the page will not save it empty.
+FOLLOW_UPS = {
+    "radioGroupIsIndicatedTitle": {
+        "guiddedApplicationAdditionalDataIndicatedByNameInput": (
+            "Name of the person who recommended you"
+        ),
+        "guiddedApplicationAdditionalDataIndicatedByEmailInput": (
+            "E-mail of the person who has referred you"
+        ),
+    },
+    "radioGroupIsCompanyEmployeeTitle": {
+        "guiddedApplicationAdditionalDataCorporateEmailInput": "Provide your corporate email",
+    },
+}
 TYPES = {
     "SELECT": FieldType.CHOICE,
+    "CONDITIONAL": FieldType.CHOICE,  # a SELECT with questions shown by its answer
     "MULTI_SELECT": FieldType.MULTI_CHOICE,
     "TEXT": FieldType.TEXT,
     "TEXT_AREA": FieldType.TEXT,
@@ -71,6 +89,11 @@ _READ_QUESTIONS = """(ids) => Object.fromEntries(ids.map(([id, title]) => {
   return [`question-${id}`, text?.value ?? null];
 }))"""
 
+# The questions page's controls: `question-<id>` radios, `checkbox-<id>-<n>` boxes, a text named by
+# its question's title.
+_SHOWN_QUESTIONS = f"""() => [...document.querySelectorAll({QUESTIONS!r})]
+  .map(e => e.name || e.id)"""
+
 
 class Gupy:
     name = "gupy"
@@ -86,6 +109,8 @@ class Gupy:
         self._questions: dict[str, dict[str, Any]] = {}
         self._fields: dict[str, Field] = {}
         self._additional: dict[str, Answer] = {}
+        self._additional_shown: list[str] = []  # saved before the questions open
+        self._given: set[str] = set()
 
     def detect(self, url: str, page: Page | None) -> bool:
         parts = urlsplit(url)
@@ -145,7 +170,7 @@ class Gupy:
                 page.wait_for_timeout(STEP_POLL_MS)
         finally:
             page.remove_listener("response", on_response)
-        fields = [_additional(raw) for raw in page.evaluate(_READ_ADDITIONAL)]
+        fields = _additional_fields(page.evaluate(_READ_ADDITIONAL))
         questions = (forms[-1].json().get("questionForm") or {}).get("questions") if forms else []
         self._questions = {f"question-{q['questionId']}": q for q in questions or []}
         fields += [_question(q) for q in self._questions.values()]
@@ -167,7 +192,7 @@ class Gupy:
                     continue
                 if button.is_enabled():
                     disabled_since = None
-                    browser.click(button)
+                    _click(lambda found=button: found)
                 # Continue Application is disabled while the resume loads, for good when the
                 # resume is incomplete
                 elif (disabled_since := disabled_since or time.monotonic()) < (
@@ -182,22 +207,44 @@ class Gupy:
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Fills Additional information and, where the posting has questions, saves it and
         opens them; the questions are filled and left unsaved for submit."""
+        self._given = set(answers)
         for field_id, answer in answers.items():
             if field_id not in self._questions:
                 _set(page, self._fields[field_id], field_id, answer)
         self._additional = self._read_additional(page)
+        self._additional_shown = [raw["id"] for raw in page.evaluate(_READ_ADDITIONAL)]
         if not self._questions:
             return
         if page.locator(ADDITIONAL).count():
             browser.click(page.locator("button:has-text('Save and continue')").first)
         answer_now = page.locator(ANSWER_NOW).first
-        answer_now.wait_for(timeout=SAVE_TIMEOUT_MS)
+        try:
+            answer_now.wait_for(timeout=SAVE_TIMEOUT_MS)
+        except Timeout:
+            if page.locator(ADDITIONAL).count():
+                raise NotTaken("the page would not save Additional information") from None
+            raise
         browser.click(answer_now)
         page.locator(QUESTIONS).first.wait_for(timeout=SAVE_TIMEOUT_MS)
         for field_id, answer in answers.items():
             if (question := self._questions.get(field_id)) is not None:
                 _answer(page, self._fields[field_id], question, answer)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """Additional information as it was saved, and the questions the page renders: a text
+        is known only by its title, which questions can share."""
+        by_title: dict[str, list[str]] = {}
+        for field_id, question in self._questions.items():
+            by_title.setdefault(question["title"], []).append(field_id)
+        for ids in by_title.values():
+            ids.sort(key=lambda i: i not in self._given)
+        shown = list(self._additional_shown)
+        for control in page.evaluate(_SHOWN_QUESTIONS) if page.locator(QUESTIONS).count() else []:
+            ids = by_title.get(control.removeprefix("input-"))
+            field_id = ids.pop(0) if ids else _question_id(control)
+            shown += [field_id] if field_id not in shown else []
+        return shown
+
     def _read_additional(self, page: Page) -> dict[str, Answer]:
         values = {raw["id"]: raw["value"] for raw in page.evaluate(_READ_ADDITIONAL)}
         return {k: v for k, v in values.items() if k in self._fields and v}
@@ -222,6 +269,23 @@ class Gupy:
         raise RuntimeError(f"{response.request.method} {response.url} answered {response.status}")
 
 
+def _additional_fields(raws: list[dict[str, Any]]) -> list[Field]:
+    """Additional information as the page has it, each radio before what its Yes shows."""
+    values = {raw["id"]: raw["value"] for raw in raws}
+    shown_by = {name for names in FOLLOW_UPS.values() for name in names}
+    fields = []
+    for raw in raws:
+        if raw["id"] in shown_by:
+            continue
+        fields.append(_additional(raw))
+        for name, label in FOLLOW_UPS.get(raw["id"], {}).items():
+            yes = Is(raw["id"], ["Yes"])
+            fields.append(
+                Field(name, label, FieldType.TEXT, True, prefilled=values.get(name), shown_when=yes)
+            )
+    return fields
+
+
 def _additional(raw: dict[str, Any]) -> Field:
     """A radio group is a choice; the source list, a combobox, is not filled."""
     name, label = raw["id"], raw["label"]
@@ -243,7 +307,8 @@ def _question(q: dict[str, Any]) -> Field:
         shown = Is(f"question-{q['parentQuestionId']}", q.get("conditionalTriggerOptions") or None)
     if kind is None:
         reason = f"unhandled_rendering: {q['title']!r} is a {q['type']} question"
-        return Field(field_id, q["title"], FieldType.TEXT, q["required"], unfillable=reason)
+        return Field(field_id, q["title"], FieldType.TEXT, q["required"], unfillable=reason,
+                     shown_when=shown)  # fmt: skip
     return Field(
         field_id, q["title"], kind, bool(q["required"]),
         options if kind is not FieldType.TEXT else None, prefilled=q.get("answer") or None,
@@ -251,6 +316,17 @@ def _question(q: dict[str, Any]) -> Field:
     )  # fmt: skip
 
 
+def _click(find: Callable[[], Locator]) -> None:
+    """Clicks what `find` finds: the page renders again as it loads, detaching what it found."""
+    for _ in range(CLICK_ATTEMPTS - 1):
+        try:
+            return browser.click(find())
+        except BrowserError as e:
+            if "not attached" not in str(e):
+                raise
+    browser.click(find())
+
+
 def _label(page: Page, selector: str, text: str) -> Locator:
     """The label, wrapping it, of the input `selector` matches whose text is `text`."""
     inputs = page.locator(selector)
@@ -263,7 +339,7 @@ def _label(page: Page, selector: str, text: str) -> Locator:
 def _set(page: Page, field: Field, field_id: str, answer: Answer) -> None:
     match field.type, answer:
         case FieldType.CHOICE, str():
-            browser.click(_label(page, f'main input[name="{field_id}"]', answer))
+            _click(lambda: _label(page, f'main input[name="{field_id}"]', answer))
         case FieldType.TEXT, str():
             page.locator(f'main input[name="{field_id}"], main input[id="{field_id}"]').fill(answer)
         case kind, _:
@@ -290,5 +366,11 @@ def _answer(page: Page, field: Field, question: dict[str, Any], answer: Answer)
             raise Unsupported(f"unhandled_rendering: cannot fill question-{qid}, a {kind}")
 
 
+def _question_id(control: str) -> str:
+    """The question of a radio or a checkbox's name; anything else as the page names it."""
+    box = re.fullmatch(r"checkbox-(\d+)-\d+", control)
+    return f"question-{box[1]}" if box else control
+
+
 def _css(text: str) -> str:
     return text.replace("\\", "\\\\").replace('"', '\\"')

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/hrmdirect.py

@@ -109,6 +109,7 @@ class HRMDirect:
     def __init__(self) -> None:
         self._jobs: dict[str, str] = {}  # by org, the last posting's job
         self._fields: dict[str, Field] = {}
+        self._walked: set[str] = set()  # the pages the read reached
         self._kinds: dict[str, str] = {}
         self._values: dict[str, Answer] = {}
         self._apply = ""
@@ -225,8 +226,9 @@ class HRMDirect:
         """Walks the wizard from its first page as far as its pages save with what they hold,
         reading each page it reaches."""
         self._open(page)
-        self._fields = {}
+        self._fields, self._walked = {}, set()
         for _ in range(MAX_PAGES):
+            self._walked.add(_active(page))
             for f in self._page(page):
                 self._fields.setdefault(f.id, f)
             if not self._continue(page):
@@ -234,8 +236,9 @@ class HRMDirect:
         return list(self._fields.values())
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
-        """Fills each page from the first and saves it, up to the last; a page showing a
-        required field the read did not list is refused, the pages before it saved."""
+        """Fills each page from the first and saves it, up to the last; a page that shows a
+        field the read did not list, or does not save, stops the fill, the pages before it
+        saved."""
         self._open(page)
         self._values = {}
         for _ in range(MAX_PAGES):
@@ -250,12 +253,25 @@ class HRMDirect:
                     control = page.locator(PAGE_FORM).locator(f"[id='{f.id}']")
                     tag = control.evaluate("el => el.tagName") if control.count() else ""
                     _fill(page, f, "select" if tag == "SELECT" else "text", answer)
-            unread = [f.id for f in shown if f.required and f.id not in self._fields]
-            if unread:
-                raise NotTaken(f"the page shows fields the read did not list: {unread}; read again")
+            self._unread(page)
             self._values |= self._read(page)
-            if _last(page) or not self._continue(page):
+            if _last(page):
                 return
+            step = _active(page)
+            if not self._continue(page):
+                raise NotTaken(f"{step} was not saved")
+
+    def _unread(self, page: Page) -> None:
+        """Stops on fields the read did not list, optional ones too, once the answers are in. A
+        page the read did not reach is read once the pages before it are saved. On one it read,
+        an answer opened the field: the page stops unsaved, so no read would list it."""
+        unread = [f for f in self._page(page) if f.id not in self._fields]
+        if not unread:
+            return
+        step, labels = _active(page), ", ".join(f.label for f in unread)
+        if step in self._walked:
+            raise Unsupported(f"unhandled_rendering: an answer showed {labels}, not listed")
+        raise NotTaken(f"{step} shows fields the read did not list: {labels}; read again")
 
     def read_back(self, page: Page) -> dict[str, Answer]:
         return self._values | self._read(page)

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/isolvedhire.py

@@ -139,6 +139,10 @@ _READ = """html => {
     } else field.kind = "text";
     out.push(field);
   }
+  if (html.includes("applicantDisabledData") && !seen.has("disabled_employee_id")) {
+    out.push({key: "disabled_employee_id", kind: "scripted", label: "Employee ID (if applicable)",
+              required: false, options: [], value: "", disabled: false});
+  }
   const app = root.querySelector("input[name=applications_id]")?.value;
   return {fields: out, app};
 }"""
@@ -190,6 +194,7 @@ class IsolvedHire:
         self._steps: list[str] = []
         self._fields: dict[str, Field] = {}
         self._raws: dict[str, dict[str, Any]] = {}  # by field id, as the read found it
+        self._shown: dict[str, None] = {}  # the fields each step showed, in order
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _job(url) is not None
@@ -284,14 +289,20 @@ class IsolvedHire:
         """Confirms the account's contact details, then walks the steps in order: each answered
         and saved with Proceed to Next Step, which goes no further while one is invalid."""
         _confirm_contact(page)
+        self._shown = {}
         for step in self._steps:
             _go(page, step)
             for field_id, field in self._fields.items():
                 if field_id.startswith(f"{step}.") and field_id in answers:
                     self._answer(page, field, answers[field_id])
             _settle(page)
+            self._shown |= dict.fromkeys(_shown(page, step))
             _next(page, step)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields each step showed once answered: the wizard holds one step at a time."""
+        return list(self._shown)
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each step as the system saved it, fetched again."""
         values: dict[str, Answer] = {}
@@ -476,6 +487,15 @@ def _read_step(page: Page, step: str) -> tuple[list[dict[str, Any]], str | None]
     return raws, read["app"]
 
 
+def _shown(page: Page, step: str) -> list[str]:
+    """The ids of the open step's fields, read as `_read_step` reads them; a disabled and empty
+    control takes no answer, `source_other` until a source asks for it."""
+    if step in ENTRY_LISTS:
+        return [f"{step}.entries"]
+    raws = page.evaluate(_READ, page.locator("#landingStrip").inner_html())["fields"]
+    return [f"{step}.{raw['key']}" for raw in raws if raw["value"] or not raw["disabled"]]
+
+
 def _texts(options: Locator) -> list[str]:
     return [" ".join(t.split()) for t in options.all_text_contents()]
 

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/taleo.py

@@ -220,7 +220,8 @@ class Taleo:
 
     def __init__(self) -> None:
         self._postings: dict[str, Posting] = {}  # by zone, the last posting's
-        self._kinds: dict[str, str] = {}  # each read field's rendering, by its id
+        self._listed: set[str] = set()  # the ids the read listed
+        self._walked: set[str] = set()  # the pages the read reached
         self._read_back: dict[str, Answer] = {}
 
     def detect(self, url: str, page: Page | None) -> bool:
@@ -289,23 +290,24 @@ class Taleo:
         fields listed. Reading saves pages, as a fill does."""
         self._open(page)
         fields: list[Field] = []
-        self._kinds = {}
+        self._walked = set()
         while not _on_review(page):
             step = _step(page)
+            self._walked.add(step)
             if step not in SKIPPED_STEPS:
                 for raw in _read(page):
-                    field = _field(step, raw)
-                    self._kinds[field.id] = raw["kind"]
-                    fields.append(field)
+                    fields.append(_field(step, raw))
                     if raw["id"].endswith(SOURCE_TYPE):
                         fields.append(_sources(page, step, raw))
             if not _save(page):
                 break
+        self._listed = {f.id for f in fields}
         return fields
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Fills each page from the first and saves it, until Review and Submit. A page that
-        does not save stops the fill with its messages."""
+        shows a field the read did not list stops the fill unsaved; one that does not save, with
+        its messages."""
         self._open(page)
         self._read_back = {}
         while not _on_review(page):
@@ -318,14 +320,26 @@ class Taleo:
                     if field_id in answers and field_id not in filled:
                         _fill(page, raw, answers[field_id])
                         filled.add(field_id)
-            for raw in _read(page) if raws else []:
+            answered = _read(page) if raws else []
+            self._unread(step, answered)
+            for raw in answered:
                 value = _value(raw)
                 if value not in (None, "", []):
                     self._read_back[_field_id(step, raw)] = value
             if not _save(page):
-                unread = any(_field_id(step, r) not in self._kinds for r in raws)
-                errors = "; ".join(_errors(page))
-                raise NotTaken(f"{step} was not saved: {errors}" + ("; read again" * unread))
+                raise NotTaken(f"{step} was not saved: {'; '.join(_errors(page))}")
+
+    def _unread(self, step: str, raws: list[dict[str, Any]]) -> None:
+        """Stops on fields the read did not list, optional ones too, once the answers are in. A
+        page the read did not reach is read once the pages before it are saved. On one it read,
+        an answer opened the field: the page stops unsaved, so no read would list it."""
+        unread = [r["label"] for r in raws if _field_id(step, r) not in self._listed]
+        if not unread:
+            return
+        labels = ", ".join(unread)
+        if step in self._walked:
+            raise Unsupported(f"unhandled_rendering: an answer showed {labels}, not listed")
+        raise NotTaken(f"{step} shows fields the read did not list: {labels}; read again")
 
     def read_back(self, page: Page) -> dict[str, Answer]:
         return dict(self._read_back)

{atsfill-0.0.8.dev219 → atsfill-0.0.8.dev221}/src/atsfill/adapters/workday.py

@@ -213,6 +213,9 @@ class Workday:
     def __init__(self) -> None:
         self._sites: dict[str, Site] = {}  # by tenant, the last posting's
         self._fields: dict[str, Field] = {}
+        self._listed: set[str] = set()  # the ids the read listed, unfillable ones too
+        self._walked: set[str] = set()  # the pages the read reached
+        self._walled = False  # no read gets past the page this one stopped on
         self._values: dict[str, Answer] = {}
         self._apply = ""
 
@@ -263,9 +266,9 @@ class Workday:
 
     def browser_read(self, page: Page) -> list[Field]:
         """Walks the wizard as far as its pages save with what they hold, reading each page
-        it reaches: from the page, else My Experience from the apply flow's sections and the
-        questions from the questionnaires, which also stand for those pages when they are not
-        reached. A page after the first that does not save is read once it does."""
+        it reaches: from the page, My Experience from the apply flow's sections and then the
+        page, and the questions from the questionnaires, which also stand for those pages when
+        they are not reached. A page after the first that does not save is read once it does."""
         found = site(page.url)
         if found is None or not (job := JOB.match(found.rest)):
             raise RuntimeError(f"{page.url} is not a Workday posting")
@@ -289,15 +292,19 @@ class Workday:
         page.goto(self._apply)
         _wait_for_page(page)
         seen: dict[str, list[Field]] = {}
+        self._walked, self._walled = set(), False
         for _ in range(MAX_PAGES):
             step = _step(page)
             if step == REVIEW:  # repeats the answers, an upload without its input
                 break
-            if not (_questions_page(step) or step == EXPERIENCE):
-                seen[step] = _read(page, f"{calypso}/jobapplication/{found.tenant}{PHONE_CODES}")
+            self._walked.add(step)
+            if not _questions_page(step):
+                phone_codes = f"{calypso}/jobapplication/{found.tenant}{PHONE_CODES}"
+                seen[step] = _read(page, phone_codes, {f.id for f in from_api.get(step, [])})
             try:
                 _save_and_continue(page)
             except NotTaken:
+                self._walled = _only_a_tick_missing(_page_fields(page))
                 break
         steps = [p["descriptor"] for p in flow.get("data") or []]
         steps += [s for s in seen if s not in steps]
@@ -305,6 +312,7 @@ class Workday:
             f for s in steps for f in seen.get(s, []) + from_api.get(_questionnaire_step(s), [])
         ]
         self._fields = {f.id: f for f in fields if not f.unfillable}
+        self._listed = {f.id for f in fields}
         return fields
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
@@ -342,19 +350,22 @@ class Workday:
         raise Unsupported(known_gap(self, "long_wizard", f"more than {MAX_PAGES} pages"))
 
     def _unread(self, page: Page) -> None:
-        """Stops on required fields the read did not list: on My Information, the address of a
-        country other than the form's, or a follow-up an answer opened (a referral's name); on a
-        later page, one the read could not reach."""
-        unread = [r for r in _page_fields(page) if r["required"] and r["id"] not in self._fields]
+        """Stops on fields the read did not list, optional ones too. A page the read did not
+        reach is read once the pages before it are saved, unless no read can get there. On one
+        it read, an answer opened the field (a country's address, a referral's name): the page
+        stops unsaved, so no read would list it."""
+        unread = _not_listed(_page_fields(page), self._listed)
         if not unread:
             return
         step, labels = _step(page), ", ".join(r["label"] for r in unread)
+        if step not in self._walked and self._walled:
+            raise Unsupported(f"unhandled_rendering: {step} shows {labels}, which no read reaches")
+        if step not in self._walked:
+            raise NotTaken(f"{step} shows fields the read did not: {labels}; read again")
         if step == MY_INFORMATION and any(r["id"].startswith(ADDRESS) for r in unread):
             detail = f"the country answered shows fields the read did not: {labels}"
             raise Unsupported(known_gap(self, "other_country", detail))
-        if step == MY_INFORMATION:
-            raise Unsupported(f"unhandled_rendering: an answer showed {labels}, not listed")
-        raise NotTaken(f"{step} shows fields the read did not: {labels}; read again")
+        raise Unsupported(f"unhandled_rendering: an answer showed {labels}, not listed")
 
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each page's values, read before it was saved; one file as its name."""
@@ -472,10 +483,23 @@ def _questionnaire_step(step: str) -> str:
     return re.sub(r" 1 of \d+$", "", step)
 
 
-def _read(page: Page, phone_codes: str) -> list[Field]:
-    """The fields the page shows, a dropdown's or a short prompt's options read by opening it,
-    the country phone codes from `phone_codes`, the API's list."""
-    raws = _page_fields(page)
+def _not_listed(raws: list[dict[str, Any]], listed: set[str]) -> list[dict[str, Any]]:
+    """The fields not in `listed`, but for a later entry of a list: the draft's, numbered anew
+    by each load, and no answer's."""
+    return [r for r in raws if r["id"] not in listed and not ENTRY_ID.match(r["id"])]
+
+
+def _only_a_tick_missing(raws: list[dict[str, Any]]) -> bool:
+    """Whether a page holds all it requires but a box: the draft keeps a page's answers but not
+    its consent's tick, so no read saves that page, whatever the fills before it saved."""
+    empty = [r for r in raws if r["required"] and r["value"] in (None, "", [], "No")]
+    return bool(empty) and all(r["kind"] == "box" for r in empty)
+
+
+def _read(page: Page, phone_codes: str, listed: set[str]) -> list[Field]:
+    """The fields the page shows that are not in `listed`, a dropdown's or a short prompt's
+    options read by opening it, the country phone codes from `phone_codes`, the API's list."""
+    raws = _not_listed(_page_fields(page), listed)
     for raw in raws:
         box = page.locator(f'[data-fkit-id="{raw["dom"]}"]')
         if raw["kind"] == "list":