atsfill 0.0.4.dev92__tar.gz → 0.0.4.dev94__tar.gz

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

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

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

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

@@ -2,10 +2,10 @@
 the employer's own domain), as docs/adapters/eightfold.md observes.
 
 A posting's apply page (`/careers/apply?pid=<pid>`) renders its form from a questions API:
-sections of questions by id, type, requirement and options, and the questions another one's
-answer shows. `read_api` fetches it over HTTP, `read_form` through the page's browser context,
-and both list the fields from it. Each question renders as a control whose element id is its
-section's title and its id, with every other character an underscore.
+sections of questions by id, type, requirement and options, and the questions whose answer
+shows each follow-up. `read_api` fetches it over HTTP, `read_form` through the page's browser
+context, and both list the fields from it. Each question renders as a control whose element id
+is its section's title and its id, with every other character an underscore.
 """
 
 import http.cookiejar
@@ -13,15 +13,15 @@ import json
 import re
 import urllib.request
 from contextlib import suppress
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, replace
 from datetime import date, datetime
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit
 
-from atsfill.core import browser
+from atsfill.core import browser, conditions
 from atsfill.core.adapter import Blocked, Gap, NotTaken, 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, AnyOf, Condition, Field, FieldType, Is, SideEffect
 
 HOST = re.compile(r"^[\w-]+\.eightfold\.ai$")
 JOB = re.compile(r"^/careers/job/(\d+)")
@@ -33,7 +33,6 @@ CSRF = re.compile(r'<meta name="_csrf" content="([^"]+)"')
 SUBMIT = "[data-test-id=submitApplicationButton]"
 AGREE = "#confirmUploadResume"  # the privacy dialog a resume upload opens
 PICKER = "[data-testid=picker-dialog]"
-MAX_DEPTH = 5  # the deepest chain of questions rendering one another that a label names"
 FORM_TIMEOUT_MS = 30_000
 SHOWN_TIMEOUT_MS = 2_000
 OPTIONS_TIMEOUT_MS = 5_000
@@ -131,8 +130,6 @@ class _Control:
     field: Field
     kind: str
     ends: list[str]  # what the control's element id ends with
-    # the questions whose answer renders it, each with the answers that do (any when empty)
-    parents: list[tuple[str, list[str]]] = field(default_factory=list)
     resume: bool = False
     dom: str | None = None
 
@@ -152,6 +149,7 @@ class Eightfold:
 
     def __init__(self) -> None:
         self._controls: list[_Control] = []  # in the form's order
+        self._fields: list[Field] = []
 
     def detect(self, url: str, page: Page | None) -> bool:
         if _pid(url) is None:
@@ -210,14 +208,16 @@ class Eightfold:
             control.dom = doms.get(control.field.id)
             if control.field.unfillable:
                 continue
-            if control.dom is None and not control.parents:
+            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)
-        fields = [c.field for c in self._controls]
+        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 fields
+        return self._fields
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         # the resume first: what its parse finds is written over the fields filled before it
@@ -226,8 +226,8 @@ class Eightfold:
         for control in order:
             if (answer := answers.get(control.field.id)) is None:
                 continue
-            if control.dom is None:  # rendered once a question that shows it is answered
-                if not any(_shows(given.get(p), values) for p, values in control.parents):
+            if control.dom is None:  # a follow-up, rendered once its condition holds
+                if not conditions.Form(self._fields, given).shown(control.field):
                     continue
                 with suppress(Timeout):
                     _box_of(page, control).wait_for(timeout=SHOWN_TIMEOUT_MS)
@@ -242,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)
@@ -320,21 +324,23 @@ def _plain(label: str) -> str:
     return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", label)).strip()
 
 
-def _label(q: dict[str, Any], by_id: dict[str, dict[str, Any]], depth: int = 0) -> str:
-    """The question's text; one some of a parent's answers render says so, naming the first
-    parent by its own label, so that a parent asked for other answers names it apart."""
+def _label(q: dict[str, Any]) -> str:
     label = _plain(q.get("label") or "")
     if (q.get("textOptions") or {}).get("type") == "number":  # a number input takes no text
         label += " (a number)"
-    first = (q.get("parentDependencies") or [{}])[0]
-    if not first.get("values") or depth > MAX_DEPTH:
-        return label
-    parent = by_id.get(str(first["questionId"]), {})
-    labels = {str(c["value"]): c["label"] for c in _choices(parent)}
-    shown = " or ".join(labels.get(str(v), str(v)) for v in first["values"])
-    named = _label(parent, by_id, depth + 1)
-    quote = '"' if "'" in named else "'"  # never escaped: the outermost is the last
-    return f"{label} (asked when {quote}{named}{quote} is {shown})"
+    return label
+
+
+def _shown_when(q: dict[str, Any], by_id: dict[str, dict[str, Any]]) -> Condition | None:
+    """What renders a follow-up: any of its parents' answers it lists, any answer where it
+    lists none."""
+    parents: list[Condition] = []
+    for dependency in q.get("parentDependencies") or []:
+        parent = by_id.get(str(dependency["questionId"]), {})
+        labels = {str(c["value"]): c["label"] for c in _choices(parent)}
+        values = [labels.get(str(v), str(v)) for v in dependency.get("values") or []]
+        parents.append(Is(str(dependency["questionId"]), values or None))
+    return parents[0] if len(parents) == 1 else AnyOf(parents) if parents else None
 
 
 def _choices(q: dict[str, Any]) -> list[dict[str, Any]]:
@@ -356,33 +362,36 @@ def _form(data: dict[str, Any]) -> list[_Control]:
 
 
 def _control(q: dict[str, Any], by_id: dict[str, dict[str, Any]]) -> _Control:
-    qid, label = str(q["questionId"]), _label(q, by_id)
+    qid, label, shown_when = str(q["questionId"]), _label(q), _shown_when(q, by_id)
     kind = KINDS.get(q.get("type", ""))
     choices = _choices(q)
     if kind == "select" and not choices and (q.get("selectOptions") or {}).get("apiEndpoint"):
         kind = "lookup"  # options load once the question it depends on is answered
     required = bool(q.get("required"))
-    parents = []
-    for dependency in q.get("parentDependencies") or []:
-        parent = by_id.get(str(dependency["questionId"]), {})
-        labels = {str(c["value"]): c["label"] for c in _choices(parent)}
-        values = [labels.get(str(v), str(v)) for v in dependency.get("values") or []]
-        parents.append((str(dependency["questionId"]), values))
-    if parents and parents[0][1]:  # asked for some of its parent's answers only
-        required = False
     ends = list(dict.fromkeys([_norm(qid), qid]))
     if kind is None:
         reason = f"unhandled_rendering: {qid} is a question of type {q.get('type')}"
-        return _Control(Field(qid, label, FieldType.TEXT, required, unfillable=reason), "", ends)
+        unfillable = Field(qid, label, FieldType.TEXT, required, unfillable=reason)
+        return _Control(replace(unfillable, shown_when=shown_when), "", ends)
     options = [c["label"] for c in choices] or None
     accept = None
     if kind == "file":
         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
-    question = Field(qid, label, TYPES[kind], required, options, accept=accept, prefilled=today)
-    return _Control(question, kind, ends, parents, q.get("type") == "resumeUpload")
+    # 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,
+        TYPES[kind],
+        required,
+        options,
+        accept=accept,
+        prefilled=today,
+        shown_when=shown_when,
+    )
+    return _Control(question, kind, ends, q.get("type") == "resumeUpload")
 
 
 def _find(page: Page, control: _Control) -> str | None:
@@ -398,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 "")
@@ -533,13 +533,5 @@ def _iso(shown: str) -> str:
     return shown
 
 
-def _shows(answer: Answer | None, values: list[str]) -> bool:
-    """Whether a parent's answer renders its dependent: any answer when `values` is empty."""
-    if answer in (None, "", []):
-        return False
-    picks = [answer] if isinstance(answer, str) else answer
-    return not values or any(p in values for p in picks)
-
-
 def _exact(value: str) -> re.Pattern[str]:
     return re.compile(rf"^\s*{re.escape(value)}\s*$")

{atsfill-0.0.4.dev92 → 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.dev92 → 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.dev92 → 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: