atsfill 0.0.4.dev92__tar.gz → 0.0.4.dev93__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev92"
+version = "0.0.4.dev93"
 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.dev93}/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,14 @@ 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]
+        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 +224,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)
@@ -320,21 +318,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,24 +356,17 @@ 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":
@@ -381,8 +374,17 @@ def _control(q: dict[str, Any], by_id: dict[str, dict[str, Any]]) -> _Control:
         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")
+    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:
@@ -533,13 +535,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.dev93}/src/atsfill/adapters/teamtailor.py

@@ -9,6 +9,7 @@ video Teamtailor holds under the id the form keeps.
 import re
 import time
 import unicodedata
+from dataclasses import replace
 from pathlib import PurePath
 from typing import Any
 from urllib.parse import urlsplit
@@ -16,7 +17,7 @@ from urllib.parse import urlsplit
 from atsfill.core import browser, matching
 from atsfill.core.adapter import Gap, NotTaken, Unsupported, known_gap
 from atsfill.core.browser import Locator, Page, Response
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 FORM = "#job-application-form"
 # A custom question, or a qualifying one: the rest of the form stays disabled until it is
@@ -73,6 +74,7 @@ _READ = """(form, QUESTION) => {
   const fields = [];
   for (const el of form.querySelectorAll("input, textarea")) {
     if (el.closest(QUESTION) || el.disabled || fields.some(f => f.id === el.name)) continue;
+    if (el.type !== "file" && /_remote_url\\]$/.test(el.name)) continue;  // an upload's address
     const kind = el.tagName === "TEXTAREA" ? "textarea"
       : el.name === "candidate[location][query]" ? "location"
       : el.type === "checkbox" && el.name.endsWith("[]") ? "choices" : el.type;
@@ -106,12 +108,13 @@ _READ = """(form, QUESTION) => {
       && form.querySelector(`[data-question-uuid="${q.dataset.questionShowIfUuid}"]`);
     const shownBy = parent && [...parent.querySelectorAll(PICKS)]
       .find(e => e.value === q.dataset.questionShowIfValue);
-    const when = shownBy && ` (asked when "${label(parent.querySelector("legend, label"))}" is`
-      + ` "${options(parent, [shownBy])[0]}")`;
-    fields.push({id: `question:${qid}`, kind, question: true, qualifying, conditional: !!parent,
-                 label: label(q.querySelector("legend, label")) + (when || ""),
-                 required: qualifying || (!parent && q.dataset.questionMandatory === "true"),
-                 asked: q.dataset.questionMandatory === "true",
+    const parentId = parent?.querySelector("input[name$='[question_id]']")?.value;
+    fields.push({id: `question:${qid}`, kind, question: true, qualifying,
+                 shownBy: parent && shownBy
+                   ? {id: `question:${parentId}`, option: options(parent, [shownBy])[0]} : null,
+                 visible: q.checkVisibility(),
+                 label: label(q.querySelector("legend, label")),
+                 required: qualifying || q.dataset.questionMandatory === "true",
                  accept: kind === "video"
                    ? q.querySelector("input[type=file]")?.accept.split(",").filter(Boolean) : null,
                  options: picks.length ? picks : menu.length ? menu : null});
@@ -176,7 +179,7 @@ class Teamtailor:
     def __init__(self) -> None:
         self._fields: dict[str, Field] = {}
         self._qualifying: set[str] = set()
-        self._follow_ups: dict[str, bool] = {}  # shown by an earlier answer: required once shown
+        self._follow_ups: set[str] = set()
         self._uploads: dict[str, str] = {}  # file field id: the answer's file name
         self._videos: dict[str, tuple[str, str]] = {}  # video field id: its video id, its URL
 
@@ -208,13 +211,15 @@ class Teamtailor:
             form.wait_for()
         except browser.Timeout:
             raise Unsupported("posting_gone: no application form on the page") from None
-        fields, self._qualifying, self._follow_ups = [], set(), {}
+        fields, self._qualifying, self._follow_ups = [], set(), set()
         for raw in form.evaluate(_READ, QUESTION):
             if raw.get("qualifying"):
                 self._qualifying.add(raw["id"])
-            if raw.get("conditional"):
-                self._follow_ups[raw["id"]] = raw["asked"]
-            fields.append(self._field(raw))
+            field = self._field(raw)
+            if shown_by := raw.get("shownBy"):  # a follow-up of an earlier question
+                self._follow_ups.add(raw["id"])
+                field = replace(field, shown_when=Is(shown_by["id"], [shown_by["option"]]))
+            fields.append(field)
         self._fields = {f.id: f for f in fields}
         return fields
 
@@ -229,10 +234,6 @@ class Teamtailor:
             if field_id in self._follow_ups and not self._shown(form, field_id):
                 continue  # not asked: the read-back leaves it out
             self._fill(form, field_id, answers[field_id])
-        for field_id, required in self._follow_ups.items():
-            if required and field_id not in answers and self._shown(form, field_id):
-                label = self._fields[field_id].label
-                raise Unsupported(f"missing_answer: an earlier answer asks {label!r}")
         self._uploads = {
             i: PurePath(a).name
             for i, a in answers.items()
@@ -240,6 +241,10 @@ class Teamtailor:
         }
         self._wait_for_uploads(form)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        raws = page.locator(FORM).evaluate(_READ, QUESTION)
+        return [raw["id"] for raw in raws if raw.get("visible", True)]
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         values = page.locator(FORM).evaluate(_READ_BACK, QUESTION)
         for field_id, (video_id, url) in self._videos.items():

{atsfill-0.0.4.dev92 → atsfill-0.0.4.dev93}/src/atsfill/core/adapter.py

@@ -143,3 +143,13 @@ class ReadsOverHttp(Adapter, Protocol):
     def read_api(self, url: str) -> list[Field] | None:
         """The same fields as `read_form`; None when it cannot for this URL."""
         ...
+
+
+@runtime_checkable
+class ListsShownFields(Adapter, Protocol):
+    """An adapter whose form can show fields after an answer: once filled, it says which the
+    page shows, so that one `read_form` did not list stops the fill (ADR 0005)."""
+
+    def shown_fields(self, page: Page) -> list[str]:
+        """The ids of the fields the filled page shows, each as `read_form` would name it."""
+        ...

{atsfill-0.0.4.dev92 → atsfill-0.0.4.dev93}/src/atsfill/core/commands.py

@@ -5,11 +5,21 @@ from importlib.metadata import version
 from pathlib import Path
 
 from atsfill.adapters import adapters
-from atsfill.core import accounts, attempts, browser, matching, passwords, paths, registry
+from atsfill.core import (
+    accounts,
+    attempts,
+    browser,
+    conditions,
+    matching,
+    passwords,
+    paths,
+    registry,
+)
 from atsfill.core.adapter import (
     Adapter,
     Blocked,
     CreatesAccount,
+    ListsShownFields,
     NeedsAccount,
     NotTaken,
     ReadsOverHttp,
@@ -21,6 +31,7 @@ from atsfill.core.browser import OutOfTime, Overlaid, Page, open_page
 from atsfill.core.results import (
     AdapterStatus,
     Answer,
+    Field,
     Result,
     SessionReport,
     Status,
@@ -160,17 +171,51 @@ def _result(adapter: Adapter, url: str, user: str) -> Result:
     return Result(Status.READY, url, adapter.name, side_effects=shown)
 
 
-def _unfillable(result: Result) -> bool:
+def _unfillable(result: Result, answers: dict[str, Answer] | None = None) -> bool:
     """Stops the form on a required field atsfill cannot fill; an optional one stays listed,
-    left empty (ADR 0014)."""
+    left empty (ADR 0014). A follow-up counts once the answers show it and require it, and
+    without answers never."""
+    form = conditions.Form(result.fields, answers or {})
     field = next(
-        (f for f in result.fields if f.unfillable and f.required and not f.prefilled), None
+        (
+            f
+            for f in result.fields
+            if f.unfillable
+            and not f.prefilled
+            and (form.required(f) if answers is not None else f.required and not f.shown_when)
+        ),
+        None,
     )
     if field:
         result.status, result.reason = Status.UNSUPPORTED, field.unfillable
     return field is not None
 
 
+def _listed(result: Result, fields: list[Field]) -> None:
+    """Sets the fields `read_form` or `read_api` listed; their conditions must name listed
+    fields, never a loop."""
+    if faults := conditions.faults(fields):
+        raise ValueError("; ".join(faults))
+    result.fields = fields
+
+
+def _shown_as_listed(
+    page: Page, adapter: Adapter, result: Result, answers: dict[str, Answer]
+) -> None:
+    """Stops a fill that showed a field `read_form` did not list, or a follow-up whose
+    condition the answers leave unmet: that condition was read wrong (ADR 0005)."""
+    if not isinstance(adapter, ListsShownFields):
+        return
+    by_id, form = {f.id: f for f in result.fields}, conditions.Form(result.fields, answers)
+    shown = adapter.shown_fields(page)
+    if new := [i for i in shown if i not in by_id]:
+        result.status = Status.UNSUPPORTED
+        result.reason = f"unhandled_rendering: an answer showed {', '.join(new)}, not listed"
+    elif wrong := [i for i in shown if not form.shown(by_id[i])]:
+        result.status = Status.REFUSED
+        result.reason = f"mismatch: {', '.join(wrong)} shows though its condition is unmet"
+
+
 def _no_adapter(url: str) -> Result:
     return Result(Status.UNSUPPORTED, url, reason="no_adapter: no adapter for this hiring system")
 
@@ -210,13 +255,16 @@ def _fill(page: Page, adapter: Adapter, url: str, answers: dict[str, Answer], us
     """Fills and reads back; `ready` when every answer reads back as given."""
     result = _result(adapter, url, user)
     with _stops(result):
-        result.fields = adapter.read_form(page)
-        if _unfillable(result):
+        _listed(result, adapter.read_form(page))
+        if _unfillable(result, answers):
             return result
         if problems := matching.problems(result.fields, answers):
             result.status, result.reason = Status.REFUSED, "invalid_answers: " + "; ".join(problems)
             return result
         adapter.fill(page, answers)
+        _shown_as_listed(page, adapter, result, answers)
+        if result.status is not Status.READY:
+            return result
         result.checks = matching.check(result.fields, answers, adapter.read_back(page))
         if mismatched := [c.field_id for c in result.checks if not c.match]:
             result.status, result.reason = Status.REFUSED, f"mismatch: {', '.join(mismatched)}"
@@ -232,7 +280,7 @@ def _read_page(
         page, adapter = opened
         result = _result(adapter, url, user)
         with _stops(result):
-            result.fields = adapter.read_form(page)
+            _listed(result, adapter.read_form(page))
             _unfillable(result)
         return result
 
@@ -301,7 +349,10 @@ def read(
             continue
         if (fields := adapter.read_api(url)) is not None:
             result = _result(adapter, url, user)
-            result.fields = fields
+            try:
+                _listed(result, fields)
+            except ValueError as e:
+                return Result(Status.UNSUPPORTED, url, adapter.name, f"adapter_error: {e}")
             _unfillable(result)
             return result
     data = paths.data_dir(data_dir)

atsfill-0.0.4.dev93/src/atsfill/core/conditions.py

@@ -0,0 +1,92 @@
+"""Whether a field shows, and whether it is required, from the answers alone (ADR 0005)."""
+
+from atsfill.core.results import AllOf, Answer, AnyOf, Condition, Field, Is
+
+
+def _parents(condition: Condition) -> list[str]:
+    match condition:
+        case Is():
+            return [condition.field_id]
+        case AnyOf():
+            return [p for c in condition.any_of for p in _parents(c)]
+        case AllOf():
+            return [p for c in condition.all_of for p in _parents(c)]
+
+
+def faults(fields: list[Field]) -> list[str]:
+    """What makes the fields' conditions unusable: a field they name that is not listed, or a
+    field shown by its own answer, through any chain."""
+    by_id = {f.id: f for f in fields}
+    out = [
+        f"{f.id}: its condition names no field {p}"
+        for f in fields
+        for c in (f.shown_when, f.required_when)
+        if c
+        for p in _parents(c)
+        if p not in by_id
+    ]
+
+    def loops(field_id: str, seen: tuple[str, ...]) -> bool:
+        if field_id in seen:
+            return True
+        field = by_id.get(field_id)
+        parents = _parents(field.shown_when) if field and field.shown_when else []
+        return any(loops(p, (*seen, field_id)) for p in parents)
+
+    out += [f"{f.id}: shown by its own answer" for f in fields if loops(f.id, ())]
+    return out
+
+
+class Form:
+    """The fields under one set of answers: an answer to a field that stays hidden counts as
+    none."""
+
+    def __init__(self, fields: list[Field], answers: dict[str, Answer]) -> None:
+        self.by_id = {f.id: f for f in fields}
+        self.answers = answers
+
+    def holds(self, condition: Condition) -> bool:
+        match condition:
+            case Is():
+                value = self._value(condition.field_id)
+                if condition.values is None:
+                    return (value is not None) != condition.negated
+                if value is None:
+                    return False
+                picks = [value] if isinstance(value, str) else value
+                return any(p in condition.values for p in picks) != condition.negated
+            case AnyOf():
+                return any(self.holds(c) for c in condition.any_of)
+            case AllOf():
+                return all(self.holds(c) for c in condition.all_of)
+
+    def shown(self, field: Field) -> bool:
+        return field.shown_when is None or self.holds(field.shown_when)
+
+    def required(self, field: Field) -> bool:
+        """Required as the form asks it: shown, and always required or required by an answer."""
+        if not self.shown(field):
+            return False
+        when = field.required_when
+        return field.required or (when is not None and self.holds(when))
+
+    def _value(self, field_id: str) -> Answer | None:
+        field = self.by_id[field_id]
+        value = self.answers.get(field_id)
+        return value if value not in (None, "", []) and self.shown(field) else None
+
+
+def describe(condition: Condition, by_id: dict[str, Field]) -> str:
+    """The condition in words, each field by its label: `"Visa" is "Yes"`."""
+    match condition:
+        case Is():
+            label = by_id[condition.field_id].label if condition.field_id in by_id else ""
+            name = f'"{label or condition.field_id}"'
+            if condition.values is None:
+                return f"{name} is {'not ' if condition.negated else ''}answered"
+            values = " or ".join(f'"{v}"' for v in condition.values)
+            return f"{name} is {'not ' if condition.negated else ''}{values}"
+        case AnyOf():
+            return " or ".join(f"({describe(c, by_id)})" for c in condition.any_of)
+        case AllOf():
+            return " and ".join(f"({describe(c, by_id)})" for c in condition.all_of)

{atsfill-0.0.4.dev92 → atsfill-0.0.4.dev93}/src/atsfill/core/matching.py

@@ -5,6 +5,7 @@ import unicodedata
 from pathlib import Path, PurePath
 from urllib.parse import urlsplit
 
+from atsfill.core.conditions import Form, describe
 from atsfill.core.results import Answer, Check, Field, FieldType
 
 
@@ -60,12 +61,19 @@ def matches(field: Field, answer: Answer, read_back: Answer | None) -> bool:
 def check(
     fields: list[Field], answers: dict[str, Answer], read_back: dict[str, Answer]
 ) -> list[Check]:
-    by_id = {f.id: f for f in fields}
-    return [
+    """Each answer against its read-back; a follow-up the answers keep hidden that reads back a
+    value is a mismatch too, its condition read wrong."""
+    by_id, form = {f.id: f for f in fields}, Form(fields, answers)
+    checks = [
         Check(f.id, a, read_back.get(f.id), matches(f, a, read_back.get(f.id)))
         for f_id, a in answers.items()
         if (f := by_id.get(f_id))
     ]
+    return checks + [
+        Check(f.id, None, read_back[f.id], False)
+        for f in fields
+        if not form.shown(f) and f.id not in answers and read_back.get(f.id) not in (None, "", [])
+    ]
 
 
 def _answer_problem(field: Field, answer: object) -> str | None:
@@ -100,13 +108,20 @@ def _answer_problem(field: Field, answer: object) -> str | None:
 
 
 def problems(fields: list[Field], answers: dict[str, Answer]) -> list[str]:
-    """What refuses a fill before typing: unknown ids, missing required answers, bad values."""
+    """What refuses a fill before typing: unknown ids, missing required answers, answers to
+    follow-ups the answers keep hidden, bad values."""
     by_id = {f.id: f for f in fields}
     out = [f"no field {i}" for i in answers if i not in by_id]
+    form = Form(fields, {i: a for i, a in answers.items() if i in by_id})
     out += [
         f"no answer for required {f.id} ({f.label})"
         for f in fields
-        if f.required and not f.prefilled and not f.unfillable and f.id not in answers
+        if form.required(f) and not f.prefilled and not f.unfillable and f.id not in answers
+    ]
+    out += [
+        f"{i}: not asked, it shows when {describe(f.shown_when, by_id)}"
+        for i in answers
+        if (f := by_id.get(i)) and f.shown_when and not form.shown(f)
     ]
     out += [
         f"{i}: cannot be filled ({f.unfillable})"

{atsfill-0.0.4.dev92 → atsfill-0.0.4.dev93}/src/atsfill/core/results.py

@@ -26,6 +26,30 @@ class FieldType(StrEnum):
 type Answer = str | list[str]
 
 
+@dataclass(frozen=True)
+class Is:
+    """Holds when the field's answer is one of `values` (one of them ticked, for a
+    multi_choice), or, without `values`, when the field is answered. Against values, it never
+    holds for an unanswered field, negated or not."""
+
+    field_id: str
+    values: list[str] | None = None
+    negated: bool = False
+
+
+@dataclass(frozen=True)
+class AnyOf:
+    any_of: list[Condition]
+
+
+@dataclass(frozen=True)
+class AllOf:
+    all_of: list[Condition]
+
+
+type Condition = Is | AnyOf | AllOf
+
+
 @dataclass(frozen=True)
 class Field:
     id: str
@@ -37,6 +61,8 @@ class Field:
     accept: list[str] | None = None
     prefilled: bool = False  # holds a value before any answer, from the account profile
     unfillable: str | None = None  # why atsfill cannot fill it, a reason (ADR 0014)
+    shown_when: Condition | None = None  # a follow-up: shown only when it holds (ADR 0005)
+    required_when: Condition | None = None  # required once shown when it holds, if not always
 
 
 @dataclass(frozen=True)