atsfill 0.0.4.dev93__tar.gz → 0.0.4.dev94__tar.gz

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.4.dev93
+Version: 0.0.4.dev94
 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.4.dev93 → atsfill-0.0.4.dev94}/pyproject.toml

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

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev93"
+version = "0.0.4.dev94"
 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.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/bamboohr.py

@@ -17,7 +17,7 @@ from urllib.parse import urlsplit
 from atsfill.core import browser
 from atsfill.core.adapter import Blocked, Gap, Unsupported
 from atsfill.core.browser import HTTP_TIMEOUT_S, Locator, Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = re.compile(r"^[\w-]+\.bamboohr\.com$")
 JOB = re.compile(r"^/careers/(\d+)(?:/|$)")
@@ -407,7 +407,10 @@ def _form(
         label, required = entry["label"].strip(), entry["isRequired"]
         options = [o["text"] for o in entry.get("options") or []] or None
         extra: Any = None
-        prefilled = key == "countryId" and bool(country)
+        shown = None  # the employer's country, the page's own before any answer
+        if key == "countryId" and country:
+            by_id = {str(o["id"]): o["text"] for o in entry.get("options") or []}
+            shown = by_id.get(str(country), country if country in by_id.values() else None)
         if key == "state" and options:
             options = _states(states, country)
         if key == "state" and not options:
@@ -416,7 +419,7 @@ def _form(
             extra = {o["id"]: o["text"] for o in entry["options"] if int(o["id"]) > 0}
             options = list(VETERAN) + list(extra.values())
         accept = FILE_TYPES if kind == "file" else None
-        field = Field(key, label, TYPES[kind], required, options, None, accept, prefilled)
+        field = Field(key, label, TYPES[kind], required, options, None, accept, default=shown)
         out.append((field, (kind, name, extra)))
     return out
 
@@ -451,11 +454,12 @@ def _custom(question: dict[str, Any]) -> list[tuple[Field, tuple[str, str | None
     field = Field(field_id, label, TYPES[kind], required, options, None, accept)
     out = [(field, (kind, name, extra))]
     if extra and OTHER in extra and question.get("hasOther") == "yes":
-        other = Field(
+        other = Field(  # its placeholder the page's only label; marked optional
             f"{field_id}_other",
-            f"{label}: please specify (asked when {label!r} is {OTHER})",
+            f"{label}: please specify",
             FieldType.TEXT,
             False,
+            shown_when=Is(field_id, [OTHER]),
         )
         out.append((other, ("text", f"{name}_other", None)))
     return out

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/dayforce.py

@@ -18,7 +18,7 @@ from urllib.parse import urlsplit
 
 from atsfill.core.adapter import Gap, Unsupported, known_gap
 from atsfill.core.browser import Locator, Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = "jobs.dayforcehcm.com"
 JOB = re.compile(r"^/(?:([a-z]{2}(?:-[A-Za-z]{2,4})?)/)?([^/]+)/([^/]+)/jobs/(\d+)")
@@ -36,6 +36,7 @@ UPDATE_TIMEOUT_MS = 5_000  # for a section to close, per Update click
 SUBMIT_TIMEOUT_MS = 90_000
 UPDATE_TRIES = 3
 FOLLOWUP_TIMEOUT_MS = 3_000
+FOLLOWUP = "Enter additional comments here"  # an option's comment box, required once shown
 DIAL_TIMEOUT_MS = 2_000  # per dial code tried, longest first
 OPTIONS_TIMEOUT_MS = 5_000  # for a dropdown's options to render
 NEXT_TRIES = 3
@@ -120,7 +121,9 @@ QUESTION_TYPES = {
     CHECKBOX: FieldType.CHOICE,
     MULTI: FieldType.MULTI_CHOICE,
 }
-DISABILITY = "DISABILITYQUESTIONNAIRE"  # its text questions (name, date, id) are the page's
+# Its text questions (name, date, id) are the page's own, disabled and filled from other
+# answers: not fields
+DISABILITY = "DISABILITYQUESTIONNAIRE"
 
 # Each option of a dropdown, by scrolling its virtual list: only a screenful is in the DOM.
 _HARVEST = """async (id) => {
@@ -185,6 +188,7 @@ class Dayforce:
         self._sections: list[dict[str, Any]] = []  # the questionnaires, in page order
         self._options: dict[str, dict[str, str]] = {}  # field id: page text to option
         self._values: dict[str, Answer | None] = {}  # read back from each page before leaving it
+        self._shown: list[str] = []  # the follow-ups each page showed before leaving it
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _job(url) is not None
@@ -234,7 +238,7 @@ class Dayforce:
             raise Unsupported("posting_gone: not a Dayforce job page")
         page.evaluate("key => sessionStorage.removeItem(key)", _draft(found))
         _open_form(page, found)
-        self._values = {}
+        self._values, self._shown = {}, []
         self._dialogs(page, answers)
         self._fill_candidate_info(page, answers)
         if not _next(page):
@@ -254,6 +258,11 @@ class Dayforce:
             values["userAcknowledged"] = "Yes" if box.is_checked() else "No"
         return {k: v for k, v in values.items() if v not in (None, "", [])}
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The follow-ups the fill saw shown on each page before leaving it: the wizard keeps
+        no page but the last, so the rest are not listed."""
+        return list(self._shown)
+
     def submit(self, page: Page) -> str | None:
         before = page.url
         page.locator("main button", has_text=re.compile(r"^\s*Submit\s*$")).last.click()
@@ -292,9 +301,9 @@ class Dayforce:
             }.get(key) or None
             fields.append(Field(key, f["displayName"], kind, bool(f["isRequired"]), options))
             if key == "candidateSource" and explained:
-                asked = f"asked when {f['displayName']!r} is {' or '.join(explained)}"
-                label = f"Additional details ({asked})"
-                fields.append(Field("candidateSourceDescription", label, FieldType.TEXT, False))
+                fields.append(Field("candidateSourceDescription", "Additional details",
+                                    FieldType.TEXT, False,
+                                    shown_when=Is("candidateSource", explained)))  # fmt: skip
         if context.get("hasActiveSMSProvider"):
             fields.append(Field("smsConsent", "Consent to receive SMS messages", FieldType.CHOICE,
                                 False, NO_YES))  # fmt: skip
@@ -373,6 +382,7 @@ class Dayforce:
         description = page.locator(_id("candidateSourceDescription"))
         if description.count():
             self._values["candidateSourceDescription"] = description.input_value()
+            self._shown.append("candidateSourceDescription")
         _update(page, f"{PERSONAL}email")
         if page.locator(f"{HOURS}sunday_isChecked").count():
             self._fill_hours(page, answers)
@@ -444,16 +454,19 @@ class Dayforce:
         target = _question_target(page, base, question)
         if target is None:
             return
-        if field_id in answers and not field.prefilled and target.is_enabled():
+        if field_id in answers and target.is_enabled():
             self._set_question(page, target, field, question, answers[field_id])
         self._values[field_id] = self._get_question(page, target, field, question)
-        followup = f"{field_id}.followup"
-        if followup in self._fields:
-            boxes = page.locator(  # a box group's is one per option asking for comments
-                f"[id='{base}answerFollowup'],"
-                f" :is(input, textarea)[id^='{base}answerFollowups_'],"
-                f" [id*='questionnaireFollowUp-{question['questionId']}-']"
-            )
+        # a box group's comment box is one per option asking for it, a single choice's one
+        followups = {f"{field_id}.followup": f"[id='{base}answerFollowup'],"
+                     f" [id*='questionnaireFollowUp-{question['questionId']}-']"}  # fmt: skip
+        for option in question["options"]:
+            box_id = f"{base}answerFollowups_{option['optionId']}"
+            followups[f"{field_id}.followup.{option['optionId']}"] = f"[id='{box_id}']"
+        for followup, selector in followups.items():
+            if followup not in self._fields:
+                continue
+            boxes = page.locator(selector)
             if followup in answers:
                 with suppress(Timeout):  # it shows once an option asking for comments is picked
                     boxes.first.wait_for(timeout=FOLLOWUP_TIMEOUT_MS)
@@ -462,6 +475,13 @@ class Dayforce:
                     box.fill(_one(answers[followup]))
             shown = [b.input_value() for b in boxes.all() if b.is_visible()]
             self._values[followup] = shown[0] if shown else ""
+            self._shown += [followup] if shown else []
+        for box in page.locator(f"[id^='{base}answerFollowup']").all():
+            box_id = box.get_attribute("id") or ""
+            option = box_id.removeprefix(f"{base}answerFollowup").removeprefix("s_")
+            followup = f"{field_id}.followup" + (f".{option}" if option else "")
+            if box.is_visible() and followup not in self._fields:
+                self._shown.append(box_id)  # a comment box `read_form` did not list
 
     def _set_question(
         self, page: Page, target: Locator, field: Field, question: dict[str, Any], answer: Answer
@@ -605,6 +625,8 @@ def _question_fields(section: dict[str, Any], question: dict[str, Any]) -> list[
     if not label or len(label) > LONG_LABEL:
         label = _plain(question["displayName"])
     field_id = f"q{question['questionId']}"
+    if section.get("xRefCode") == DISABILITY and question["answerType"] == TEXT:
+        return []
     if kind is None:
         reason = f"unhandled_rendering: {field_id} has answer type {question['answerType']}"
         required = bool(question["isRequired"])
@@ -614,13 +636,23 @@ def _question_fields(section: dict[str, Any], question: dict[str, Any]) -> list[
         options = YES_NO
     elif kind in (FieldType.CHOICE, FieldType.MULTI_CHOICE):
         options = [_option_label(o) for o in question["options"]]
-    prefilled = section.get("xRefCode") == DISABILITY and question["answerType"] == TEXT
-    fields = [Field(field_id, label, kind, bool(question["isRequired"]), options,
-                    prefilled=prefilled)]  # fmt: skip
-    asking = [_option_label(o) for o in question["options"] if o.get("hasFollowUp")]
-    if asking:
-        followup = f"Additional comments (asked when {label!r} is {' or '.join(asking)})"
-        fields.append(Field(f"{field_id}.followup", followup, FieldType.TEXT, False))
+    fields = [Field(field_id, label, kind, bool(question["isRequired"]), options)]
+    asking = [o for o in question["options"] if o.get("hasFollowUp")]
+    if question["answerType"] == MULTI:  # a comment box per option ticked
+        fields += [
+            Field(
+                f"{field_id}.followup.{o['optionId']}",
+                FOLLOWUP,
+                FieldType.TEXT,
+                True,
+                shown_when=Is(field_id, [_option_label(o)]),
+            )  # fmt: skip
+            for o in asking
+        ]
+    elif asking:
+        picks = [_option_label(o) for o in asking]
+        fields.append(Field(f"{field_id}.followup", FOLLOWUP, FieldType.TEXT, True,
+                            shown_when=Is(field_id, picks)))  # fmt: skip
     return fields
 
 

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/eightfold.py

@@ -211,8 +211,10 @@ class Eightfold:
             if control.dom is None and not control.field.shown_when:
                 reason = f"unhandled_rendering: {control.field.id} is not on the page"
                 control.field = replace(control.field, unfillable=reason)
-            elif control.dom is not None and _prefilled(page, control):
-                control.field = replace(control.field, prefilled=True)
+        held = self._values(page, [c for c in self._controls if c.dom and not c.field.unfillable])
+        for control in self._controls:
+            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._controls = [c for c in self._controls if not c.field.unfillable]
         return self._fields
@@ -240,10 +242,14 @@ class Eightfold:
         doms = page.evaluate(_DOM_IDS, unplaced) if unplaced else {}
         for control in self._controls:
             control.dom = control.dom or doms.get(control.field.id)
-        shown = [c for c in self._controls if c.dom]
-        values = page.evaluate(_READ_BACK, [[c.field.id, c.dom, c.kind] for c in shown])
+        return self._values(page, [c for c in self._controls if c.dom])
+
+    @staticmethod
+    def _values(page: Page, controls: list[_Control]) -> dict[str, Answer]:
+        """What each rendered control shows, a date in ISO; those showing nothing left out."""
+        values = page.evaluate(_READ_BACK, [[c.field.id, c.dom, c.kind] for c in controls])
         out: dict[str, Answer] = {}
-        for control in shown:
+        for control in controls:
             value = values.get(control.field.id)
             if control.kind == "date" and value:
                 value = _iso(value)
@@ -373,7 +379,8 @@ def _control(q: dict[str, Any], by_id: dict[str, dict[str, Any]]) -> _Control:
         files = q.get("resumeOptions") or q.get("fileUploadOptions") or {}
         types = files.get("acceptedFileTypes") or (files.get("fileFormats") or "").split(",")
         accept = [t.strip() for t in types if t.strip()] or None
-    today = bool((q.get("dateOptions") or {}).get("today"))  # today's date, read-only
+    # today's date, read-only: the page takes no other, so it stands for the answer
+    today = date.today().isoformat() if (q.get("dateOptions") or {}).get("today") else None
     question = Field(
         qid,
         label,
@@ -400,15 +407,6 @@ def _box(page: Page, control: _Control):
     return page.locator(f"[id={json.dumps(f'{control.dom}_error')}]").locator("xpath=..")
 
 
-def _prefilled(page: Page, control: _Control) -> bool:
-    if control.kind in ("text", "select", "date"):
-        el = _box(page, control).locator("input:not([type=file]), textarea").first
-        return bool(el.count() and el.input_value())
-    if control.kind == "pills":
-        return _box(page, control).locator("[id^=selectPilllist]").count() > 0
-    return False
-
-
 def _fill(page: Page, control: _Control, answer: Answer) -> None:
     box = _box(page, control)
     value = answer if isinstance(answer, str) else (answer[0] if answer else "")

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/hireology.py

@@ -18,7 +18,7 @@ from urllib.parse import urlsplit
 from atsfill.core import browser
 from atsfill.core.adapter import Gap, Unsupported
 from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = "careers.hireology.com"
 JOB = re.compile(r"^/[^/]+/(\d+)(?:/|$)")
@@ -101,16 +101,17 @@ LABELS = {
 }
 # The page's heading of a section whose labels repeat others' ("City").
 SECTIONS = {"experience": "Work history: ", "education": "Education: ", "military": "Military: "}
-# A field the page shows only once another is answered: (that field, the answers that show it).
-SHOWN_BY = {
-    "referred_by": ("candidate_referred", "is Yes"),
-    "non_complete_in_place_reason": ("non_complete_in_place", "is Yes"),
-    "relocate_reason": ("relocate", "is Yes"),
-    "extra_activities": ("participation_extra_activities", "is Yes"),
-    "part_time_text": ("part_time", "is Yes"),
-    "academic_awards": ("gained_academic_awards", "is Yes"),
+# A field the page shows only once another is answered, and on which answers: the school fields
+# stay hidden until an education is picked.
+SHOWN_BY: dict[str, Is] = {
+    "referred_by": Is("candidate_referred", ["Yes"]),
+    "non_complete_in_place_reason": Is("non_complete_in_place", ["Yes"]),
+    "relocate_reason": Is("relocate", ["Yes"]),
+    "extra_activities": Is("participation_extra_activities", ["Yes"]),
+    "part_time_text": Is("part_time", ["Yes"]),
+    "academic_awards": Is("gained_academic_awards", ["Yes"]),
     **{
-        f: ("military", "is Yes")
+        f: Is("military", ["Yes"])
         for f in (
             "army_branch",
             "highest_rank",
@@ -122,7 +123,7 @@ SHOWN_BY = {
         )
     },
     **{
-        f: ("highest_grade", "is not Did Not Complete High School")
+        f: Is("highest_grade", ["Did Not Complete High School"], negated=True)
         for f in ("institute_name", "graduation_year", "education_city", "education_state_id")
     },
 }
@@ -230,6 +231,10 @@ class Hireology:
         self._kinds = {field.id: kind for field, kind in out if not field.unfillable}
         return [f for f, _ in out]
 
+    def shown_fields(self, page: Page) -> list[str]:
+        form = page.locator(FORM)
+        return [i for i in self._kinds if form.evaluate(_CONTROL, i) is not None]
+
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         form = page.locator(FORM)
         for field_id, kind in self._kinds.items():  # a question before the fields it shows
@@ -293,7 +298,7 @@ def _exact(value: str) -> re.Pattern[str]:
 
 def _form(api: dict[str, Any]) -> list[tuple[Field, str]]:
     """Each field of the form API's template with its API type; an entry the page can repeat
-    is read once, as its first."""
+    is read once, as its first. A field shown by one the form does not ask is never shown."""
     out = []
     for section in api["template"]["sections"]:
         for fieldset in section["fieldsets"]:
@@ -301,7 +306,8 @@ def _form(api: dict[str, Any]) -> list[tuple[Field, str]]:
                 out.append(
                     (_field(entry, SECTIONS.get(section["id"], "")), entry["attributes"]["type"])
                 )
-    return out
+    ids = {f.id for f, _ in out}
+    return [(f, k) for f, k in out if f.id not in SHOWN_BY or SHOWN_BY[f.id].field_id in ids]
 
 
 def _field(entry: dict[str, Any], section: str) -> Field:
@@ -316,20 +322,30 @@ def _field(entry: dict[str, Any], section: str) -> Field:
     if kind not in TYPES:
         reason = f"unhandled_rendering: {field_id} is a {kind}"
         return Field(
-            field_id, label, FieldType.TEXT, bool(attributes.get("required")), unfillable=reason
-        )
+            field_id, label, FieldType.TEXT, bool(attributes.get("required")), unfillable=reason,
+            shown_when=SHOWN_BY.get(field_id),
+        )  # fmt: skip
     required = attributes["required"] and kind != "checkbox"  # a box left clear is an answer
     options = [o["name"] for o in attributes["options"]] or None
     if kind == "checkbox":
         options = YES_NO
     elif kind == "month":
         label += MONTH
-    if shown_by := SHOWN_BY.get(field_id):
-        trigger, condition = shown_by
-        label += f" (asked when {section + LABELS[trigger]!r} {condition})"
-        required = False
     max_length = attributes.get("maxlength") if TYPES[kind] is FieldType.TEXT else None
     if kind == "month":
         max_length = None
     accept = FILE_TYPES if kind == "file" else None
-    return Field(field_id, label, TYPES[kind], required, options, max_length, accept)
+    return Field(
+        field_id, label, TYPES[kind], required, options, max_length, accept,
+        default=_default(attributes, kind), shown_when=SHOWN_BY.get(field_id),
+    )  # fmt: skip
+
+
+def _default(attributes: dict[str, Any], kind: str) -> str | None:
+    """The answer the page shows picked before any, from the API's `value`: an option's name,
+    a box's `Yes` or `No`."""
+    value = attributes.get("value")
+    if kind == "checkbox" and isinstance(value, bool):
+        return YES_NO[0] if value else YES_NO[1]
+    names = {str(o.get("value")): o["name"] for o in attributes.get("options") or []}
+    return names.get(str(value)) if isinstance(value, str | int) else None

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/jazzhr.py

@@ -8,13 +8,14 @@ by which boxes are checked.
 
 import re
 from contextlib import suppress
+from dataclasses import replace
 from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
 from atsfill.core.adapter import Blocked, Gap, Unsupported
 from atsfill.core.browser import Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = re.compile(r"^[\w-]+\.applytojob\.com$")
 JOB = re.compile(r"^/apply/([A-Za-z0-9]{10})\b")
@@ -23,6 +24,9 @@ CAPTCHA = "#resumator-recaptcha iframe[title=reCAPTCHA]"
 CHALLENGE = "iframe[src*='recaptcha/api2/bframe']"
 RESUME_TYPES = [".pdf", ".doc", ".docx", ".odt", ".txt", ".rtf"]  # as the page states them
 YES_NO = ["Yes", "No"]
+DISABILITY = "eeoc_disability"  # form CC-305: its name and date are signed once one is declared
+SIGNED = ("eeoc_disability_signature", "eeoc_disability_date")
+DECLARED = re.compile(r"^\s*YES\b", re.IGNORECASE)
 FORM_TIMEOUT_MS = 20_000
 CAPTCHA_TIMEOUT_MS = 20_000
 SUBMIT_TIMEOUT_MS = 90_000
@@ -143,7 +147,7 @@ class JazzHR:
         for raw in form.evaluate(_READ):
             fields.append(_field(raw))
             self._fields[raw["id"]] = (raw["kind"], raw["selector"])
-        return fields
+        return _signed_on_disability(fields)
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         form = page.locator(FORM)
@@ -217,6 +221,17 @@ def _job(url: str) -> tuple[str, str] | None:
     return (host, match[1]) if match else None
 
 
+def _signed_on_disability(fields: list[Field]) -> list[Field]:
+    """The disability form's name and date, required by the page once a disability is
+    declared."""
+    status = next((f for f in fields if f.id == DISABILITY), None)
+    declared = [o for o in (status.options if status else None) or [] if DECLARED.match(o)]
+    if not declared:
+        return fields
+    signed = Is(DISABILITY, declared)
+    return [replace(f, required_when=signed) if f.id in SIGNED else f for f in fields]
+
+
 def _field(raw: dict[str, Any]) -> Field:
     kind, options = raw["kind"], raw.get("options")
     match kind:

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/manatal.py

@@ -13,7 +13,7 @@ from urllib.parse import urlsplit
 
 from atsfill.core.adapter import Blocked, Gap, Unsupported, known_gap
 from atsfill.core.browser import HTTP_TIMEOUT_S, Page
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = "www.careers-page.com"
 API = f"https://{HOST}/api/v1.0/"
@@ -333,10 +333,11 @@ class Manatal:
         )
 
     def _other_field(self, field: Field) -> Field:
-        """The text box an answer of Other opens, asked only then."""
+        """The text box an answer of Other opens, required where its list is."""
         fid = f"{field.id}.other"
         gap = known_gap(self, "other", f"{fid} is the text box an answer of {OTHER} opens")
-        return Field(fid, f"{field.label}: {OTHER}", FieldType.TEXT, False, unfillable=gap)
+        return Field(fid, f"{field.label}: {OTHER}", FieldType.TEXT, field.required,
+                     unfillable=gap, shown_when=Is(field.id, [OTHER]))  # fmt: skip
 
     @staticmethod
     def _shown(page: Page, entry: dict[str, Any]) -> list[str] | None:

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/oracle.py

@@ -635,5 +635,5 @@ def _field(raw: dict[str, Any]) -> Field:
         options,
         raw.get("maxLength"),
         raw.get("accept"),
-        prefilled=bool(raw.get("value")),
+        default=raw.get("value") or None,  # no account: the page's own, the visitor's country
     )

{atsfill-0.0.4.dev93 → atsfill-0.0.4.dev94}/src/atsfill/adapters/paylocity.py

@@ -20,7 +20,7 @@ from urllib.parse import urlsplit
 
 from atsfill.core.adapter import Gap, Unsupported, known_gap
 from atsfill.core.browser import HTTP_TIMEOUT_S, Locator, Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = "recruiting.paylocity.com"
 JOB = re.compile(r"^/Recruiting/Jobs/(?:Details|Apply)/(\d+)", re.IGNORECASE)
@@ -317,6 +317,7 @@ class Paylocity:
     def __init__(self) -> None:
         self._form: list[tuple[Field, Control]] = []
         self._values: dict[str, Answer] = {}  # the read-back of the steps left behind
+        self._shown: list[str] = []  # the fields each step showed
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _job(url) is not None
@@ -351,7 +352,7 @@ class Paylocity:
         return [f for f, _ in form]
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
-        self._values = {}
+        self._values, self._shown = {}, []
         page.locator("form, #app").first.wait_for(timeout=FORM_TIMEOUT_MS)
         if "resume" in answers:  # first: a parsed resume fills fields the answers then override
             _upload_resume(page, _one(answers["resume"]))
@@ -360,9 +361,14 @@ class Paylocity:
                 if field.id in answers and field.id != "resume" and _present(page, control):
                     _fill(page, control, answers[field.id])
             self._values.update(self._read(page))
+            self._shown += [f.id for f, c in self._form if _present(page, c)]
             if not page.locator(NEXT).count() or not _next(page):
                 return
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The listed fields each step showed once filled: the wizard keeps only its last."""
+        return list(dict.fromkeys(self._shown))
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         values = {**self._values, **self._read(page)}
         return {k: v for k, v in values.items() if v not in (None, "", [])}
@@ -398,7 +404,7 @@ def _form(data: dict[str, Any]) -> list[tuple[Field, Control]]:
     """The fields and their controls, in the page's order, from the apply page's pageData."""
     custom = data["customJobApplication"]
     out: list[tuple[Field, Control]] = []
-    labels: dict[str, str] = {}
+    ids: dict[str, str] = {}  # a listed control's field id, by its DOM id
 
     def add(spec: Spec, field: dict[str, Any], prefix: str = "", n: int = 0) -> None:
         dom = spec.dom.format(n=n)
@@ -410,13 +416,12 @@ def _form(data: dict[str, Any]) -> list[tuple[Field, Control]]:
             options = [o["value" if spec.kind == "state" else "text"] for o in listed]
         label = prefix + (spec.label or _plain(field["displayName"]))
         required = field["isRequired"] if spec.required is None else spec.required
-        if spec.when:
-            trigger, value = spec.when
-            label += f" (asked when {labels.get(trigger, trigger)!r} is {value})"
-        labels[dom] = label
-        field_id = FILE_IDS.get(dom, dom)
+        shown_when = None
+        if spec.when and spec.when[0] in ids:
+            shown_when = Is(ids[spec.when[0]], [spec.when[1]])
+        field_id = ids[dom] = FILE_IDS.get(dom, dom)
         out.append((Field(field_id, label, TYPES[spec.kind], bool(required), options,
-                          spec.max_length),
+                          spec.max_length, shown_when=shown_when),
                     Control(spec.kind, dom, options)))  # fmt: skip
 
     add(RESUME, {"isRequired": bool(custom.get("requireResume") or data.get("requireResume"))})