atsfill 0.0.4.dev99__tar.gz → 0.0.4.dev101__tar.gz

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev99"
+version = "0.0.4.dev101"
 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.dev99 → atsfill-0.0.4.dev101}/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, Is, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, OptionSet, SideEffect
 
 HOST = re.compile(r"^[\w-]+\.bamboohr\.com$")
 JOB = re.compile(r"^/careers/(\d+)(?:/|$)")
@@ -411,25 +411,41 @@ def _form(
         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)
+        option_sets = None
         if key == "state" and options:
-            options = _states(states, country)
-        if key == "state" and not options:
+            countries = result["formFields"].get("countryId") or {}
+            options, option_sets = None, _states(states, countries.get("options") or [])
+        if key == "state" and not option_sets:
             kind = "text"
         if kind == "veteran":
             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, default=shown)
+        field = Field(
+            key,
+            label,
+            TYPES[kind],
+            required,
+            options,
+            None,
+            accept,
+            default=shown,
+            option_sets=option_sets,
+        )
         out.append((field, (kind, name, extra)))
     return out
 
 
-def _states(states: dict[str, Any], default: str | None) -> list[str]:
-    """The state lists of every country that has one, the default country's (an id) first:
-    the list the page shows follows the country answered."""
-    order = sorted(STATE_LISTS, key=lambda c: c != default)
-    names = [s["full_name"] for c in order for s in (states.get(c) or {}).get("data") or []]
-    return list(dict.fromkeys(names))
+def _states(states: dict[str, Any], countries: list[dict[str, Any]]) -> list[OptionSet]:
+    """The state list of each country that has one, under that country as the form lists it;
+    any other country's state is typed."""
+    by_id = {str(o["id"]): o["text"] for o in countries}
+    return [
+        OptionSet(Is("countryId", [by_id[c]]), names)
+        for c in STATE_LISTS
+        if c in by_id
+        and (names := [s["full_name"] for s in (states.get(c) or {}).get("data") or []])
+    ]
 
 
 def _custom(question: dict[str, Any]) -> list[tuple[Field, tuple[str, str | None, Any]]]:

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/adapters/oracle.py

@@ -18,7 +18,7 @@ from urllib.parse import urlsplit
 from atsfill.core import browser, matching
 from atsfill.core.adapter import Blocked, Gap, NotTaken, Unsupported, known_gap
 from atsfill.core.browser import Locator, Page
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, OptionSet, SideEffect
 
 JOB = re.compile(r"/hcmUI/CandidateExperience/[\w-]+/sites/[^/]+/job/(\d+)")
 EMAIL = "email"
@@ -517,15 +517,24 @@ def _click(page: Page, target: Locator) -> None:
 def _geography(described: list[tuple[dict, Field]]) -> list[tuple[dict, Field]]:
     """Leaves one field of the address's geography (state, city, postal code), the most
     specific: its items name the levels above (`0200, Acton, ACT`), and picking one fills
-    them. It is required when any level is."""
+    them. It is required when any level is, and a dependent list of the country."""
     levels = [(r, f) for r, f in described if r.get("geo") and f.id != COUNTRY]
     if len(levels) < 2 or not any(f.options for _, f in levels):
         return described
     parts = lambda f: max(len(o.split(",")) for o in f.options or [""])  # noqa: E731
     kept = max(levels, key=lambda rf: parts(rf[1]))
     required = any(f.required for _, f in levels)
+    asked = replace(kept[1], required=required)
+    country = next((f.default for _, f in described if f.id == COUNTRY), None)
+    if isinstance(country, str):
+        # its items are the country's the page shows; another's cost a request
+        asked = replace(
+            asked,
+            options=None,
+            option_sets=[OptionSet(Is(COUNTRY, [country]), asked.options or [])],
+        )
     return [
-        (r, replace(f, required=required) if (r, f) == kept else f)
+        (r, asked if (r, f) == kept else f)
         for r, f in described
         if (r, f) == kept or (r, f) not in levels
     ]

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/adapters/paycor.py

@@ -7,13 +7,15 @@ to `ApplyJob.action` on Submit. `browser_read` walks those pages to the form, `f
 again with the answers.
 """
 
+import json
 import re
+from dataclasses import replace
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit
 
 from atsfill.core.adapter import Blocked, Gap, NotTaken, Unsupported
 from atsfill.core.browser import Page
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, OptionSet, SideEffect
 
 HOST = "recruitingbypaycor.com"
 CAREER = f"https://{HOST}/career/"
@@ -120,6 +122,20 @@ _HIDDEN = """name => {
 }"""
 
 
+# Each country select with its state select, and the page scripts' text, which holds every
+# country's state list (`var ca_country_states = [...]`).
+_COUNTRIES = """() => ({
+  countries: [...document.querySelectorAll('#gnewtonForm select[data-state-id]')].map(c => ({
+    name: c.name,
+    state: document.getElementById(c.dataset.stateId)?.name,
+    options: [...c.options].filter(o => o.value)
+      .map(o => [o.value, o.textContent.replace(/\\s+/g, ' ').trim()]),
+  })),
+  scripts: [...document.scripts].map(s => s.textContent).join('\\n'),
+})"""
+STATE_LIST = re.compile(r"var (\w+)_country_states\s*=\s*(\[[^\]]*\])")
+
+
 def _ids(url: str) -> tuple[str, str] | None:
     """The client and job ids of a Paycor career URL, or of an employer page opening it."""
     query = parse_qs(urlsplit(url).query)
@@ -138,6 +154,36 @@ def _field(control: dict[str, Any]) -> Field:
     return Field(fid, label, KINDS[kind], control["required"], control["options"], control["max"])
 
 
+def _dependent(controls: list[tuple[Field, str]], page: dict[str, Any]) -> list[tuple[Field, str]]:
+    """A state select under its country: the page's list for each country that has one, none
+    for any other, where the page disables the state and drops its `required`. Unanswered, the
+    country leaves the list the page starts with."""
+    lists = {
+        code: [s if isinstance(s, str) else s.get("value", "") for s in json.loads(names)]
+        for code, names in STATE_LIST.findall(page["scripts"])
+    }
+    under = {c["state"]: c for c in page["countries"] if c["state"]}
+    out = []
+    for field, kind in controls:
+        if (country := under.get(field.id)) and kind == "select":
+            sets = [OptionSet(Is(country["name"], negated=True), field.options or [])]
+            sets += [
+                OptionSet(Is(country["name"], [text]), lists[code.lower()])
+                for code, text in country["options"]
+                if code.lower() in lists
+            ]
+            having = [text for code, text in country["options"] if code.lower() in lists]
+            field = replace(
+                field,
+                required=False,
+                required_when=Is(country["name"], having) if field.required else None,
+                options=[],
+                option_sets=sets,
+            )
+        out.append((field, kind))
+    return out
+
+
 class Paycor:
     name = "paycor"
     known_gaps: dict[str, Gap] = {}
@@ -175,6 +221,7 @@ class Paycor:
         self._before, self._codes = [], {}
         self._walk(page, None)
         controls = [(_field(c), c["kind"]) for c in page.evaluate(_CONTROLS)]
+        controls = _dependent(controls, page.evaluate(_COUNTRIES))
         self._controls = [(f, kind) for f, kind in controls if not f.unfillable]
         return [f for f, _ in self._before] + [f for f, _ in controls]
 

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/adapters/phenom.py

@@ -25,7 +25,17 @@ from urllib.parse import parse_qs, urlsplit
 from atsfill.core import browser, matching
 from atsfill.core.adapter import Gap, NotTaken, Unsupported, known_gap
 from atsfill.core.browser import HTTP_TIMEOUT_S, BrowserError, Locator, Overlaid, Page, Timeout
-from atsfill.core.results import AllOf, Answer, AnyOf, Condition, Field, FieldType, Is, SideEffect
+from atsfill.core.results import (
+    AllOf,
+    Answer,
+    AnyOf,
+    Condition,
+    Field,
+    FieldType,
+    Is,
+    OptionSet,
+    SideEffect,
+)
 
 JOB = re.compile(r"^(/[a-z]{2,8}/[a-z]{2})/(job|\w*apply)(?:/|$)")
 APPLY = re.compile(r"^/[a-z]{2,8}/[a-z]{2}/\w*apply$")  # `apply`, `hvhapply` for hourly roles
@@ -648,6 +658,18 @@ class _Config:
                  if isinstance(v, dict) and v.get("htmlType") == "sourceTypeSchema"),
                 None,
             )  # fmt: skip
+            if raw["parent"]:  # the sources under each "how you heard" answer
+                scope = path.rpartition(".")[0]
+                at = f"{scope}.{raw['parent']}" if scope else raw["parent"]
+                raw["option_sets"] = [
+                    OptionSet(Is(at, [self.text(parent.get("title"))]), _unique(
+                        self.text(child.get("key"))
+                        for child in parent.get("child") or []
+                        if child.get("show") is not False
+                    ))
+                    for parent in u.get("data") or []
+                ]  # fmt: skip
+                return None
             return _unique(
                 self.text(child.get("key"))
                 for parent in u.get("data") or []
@@ -672,7 +694,7 @@ class _Config:
             pairs = self.dependent_list(raw, u.get("dependentKey") or parents[0], api)
         elif html == "asyncselect" and api and api.get("payload"):
             pairs = self.loaded_list(u, api)
-        elif table := self.source_table(path.rsplit(".", 1)[-1]):
+        elif table := self.source_table(raw):
             pairs = table
         else:
             values = p.get("enum") or get(p, "items.enum") or []
@@ -685,6 +707,8 @@ class _Config:
         listed = ([v for v, _ in pairs], [t for _, t in pairs])
         self.listed[path] = listed
         self.listed.setdefault(path.rsplit(".", 1)[-1], listed)  # as a workflow names it
+        if raw.get("option_sets"):  # a dependent list's, under its parents' answers before any
+            return None
         return _unique(t for _, t in pairs) or None
 
     def loaded_list(self, u: dict, api: dict) -> list[tuple[Any, str]]:
@@ -723,10 +747,10 @@ class _Config:
 
     def dependent_list(self, raw: dict, parent: str, request: dict) -> list[tuple[Any, str]]:
         """A dependent list's options under its parent's answer before any: the parent's
-        default, else the job's country where the parent lists it, else its first option. The
-        label names that answer."""
-        scope = raw["id"].rpartition(".")[0]  # a parent in the same entry, else at the top
-        at = f"{scope}.{parent}" if f"{scope}.{parent}" in self.labels else parent
+        default, else the job's country where the parent lists it, else its first option. Its
+        one option set is keyed to that answer, and to another parent's where the page holds
+        one; under any other answer its options are unknown, each set costing a request."""
+        at = self.scoped(raw, parent)
         value, shown = self.prefilled(parent)
         values, texts = self.listed.get(at) or self.listed.get(parent) or ([], [])
         country = re.sub(r"\W", "", self.ddo.get("jobCountry") or "").lower()
@@ -744,8 +768,11 @@ class _Config:
         if value is None:
             return []
         payload = request.get("payload") or ""
+        when: list[Condition] = [Is(at, [shown])]
         for name in ANSWER.findall(payload):
-            held = value if name == parent else self.prefilled(name)[0]
+            held, held_shown = (value, shown) if name == parent else self.prefilled(name)
+            if name != parent and held is not None:
+                when.append(Is(self.scoped(raw, name), [held_shown]))
             payload = payload.replace(f"%%formData.{name}%%", str(held or ""))
         data = get(self.call(payload), "applyGetReferences.data")
         if isinstance(data, dict):
@@ -756,41 +783,55 @@ class _Config:
             if isinstance(d, dict)
         ]
         if pairs:
-            raw["label"] += f" (options for {self.labels.get(at, parent)!r} {shown!r})"
+            options = _unique(t for _, t in pairs if t)
+            raw["option_sets"] = [OptionSet(when[0] if len(when) == 1 else AllOf(when), options)]
             raw["parent"] = at
         return pairs
 
-    def source_table(self, name: str) -> list[tuple[Any, str]]:
+    def source_table(self, raw: dict) -> list[tuple[Any, str]]:
         """A list Phenom's applicant-source workflow fills from its own table: the sources,
-        or the sub-sources under every source, in order."""
+        or the sub-sources under every source, in order. A table keyed by the value of the
+        field the workflow follows is a dependent list: one option set per source."""
         for flow in self.config.get("workflow") or []:
             nodes = flow.get("workflows") or []
-            if name not in _targets(nodes):
+            if raw["id"].rsplit(".", 1)[-1] not in _targets(nodes):
                 continue
             for node in nodes:
                 for table in (
                     get(node, "data.config") or [] if node.get("type") == "temp_data" else []
                 ):
                     data = table.get("data") if table.get("key") == "jsonData" else None
-                    rows = (
-                        data
-                        if isinstance(data, list)
-                        else [
-                            row
-                            for rows in (data or {}).values()
-                            if isinstance(rows, list)
-                            for row in rows
+                    groups = data if isinstance(data, dict) else {None: data}
+                    pairs = {
+                        key: [
+                            (r.get("value"), self.text(r.get("display")))
+                            for r in rows
+                            if isinstance(r, dict)
                         ]
-                    )
-                    pairs = [
-                        (r.get("value"), self.text(r.get("display")))
-                        for r in rows
-                        if isinstance(r, dict)
-                    ]
-                    if pairs:
-                        return pairs
+                        for key, rows in groups.items()
+                        if isinstance(rows, list)
+                    }
+                    if not any(pairs.values()):
+                        continue
+                    parent = get(flow, "params.field")
+                    at = parent and self.scoped(raw, parent)
+                    values, texts = self.listed.get(at or "") or ([], [])
+                    shown = dict(zip(map(str, values), texts, strict=False))
+                    if isinstance(data, dict) and shown:
+                        raw["option_sets"] = [
+                            OptionSet(Is(at, [shown[key]]), _unique(t for _, t in rows if t))
+                            for key, rows in pairs.items()
+                            if key in shown
+                        ]
+                        raw["parent"] = at
+                    return [pair for rows in pairs.values() for pair in rows]
         return []
 
+    def scoped(self, raw: dict, name: str) -> str:
+        """A field `raw` names: in the same entry, else at the top."""
+        scope = raw["id"].rpartition(".")[0]
+        return f"{scope}.{name}" if f"{scope}.{name}" in self.labels else name
+
     def prefilled(self, name: str) -> tuple[Any, str]:
         """The answer a list holds before any: the page's value it names, else its default."""
         prop = get(self.config, f"schema.properties.{name}") or {}
@@ -1133,7 +1174,10 @@ def _field(raw: dict[str, Any]) -> Field:
     if kind == "checkbox":  # an optional box starts clear
         options = YES_NO if raw["required"] else NO_YES
     label = raw["label"] + {"month": MONTH, "year": YEAR}.get(kind, "")
-    field_type = FieldType.TYPEAHEAD if kind == "typeahead" and not options else TYPES[kind]
+    sets = raw.get("option_sets")
+    field_type = (
+        FieldType.TYPEAHEAD if kind == "typeahead" and not options and not sets else TYPES[kind]
+    )
     return Field(
         raw["id"],
         label,
@@ -1145,6 +1189,7 @@ def _field(raw: dict[str, Any]) -> Field:
         default=raw.get("default"),
         shown_when=raw.get("when"),
         required_when=raw.get("required_when"),
+        option_sets=sets,
     )
 
 

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/adapters/smartrecruiters.py

@@ -35,6 +35,7 @@ KEY_DELAY_MS = 20
 LOCATION_KEY_DELAY_MS = 30
 NEXT_TRIES = 3
 YES_NO = ["Yes", "No"]
+NUMBER = re.compile(r"-?\d+([.,]\d+)?")  # what an `input[type=number]` takes
 
 # The profile page: (field id, the input, the element carrying `label` and `required`).
 PROFILE = [
@@ -221,6 +222,8 @@ class SmartRecruiters:
         if kind in SKIPPED:
             return []
         label = _plain(question["label"])
+        if kind == "currency":  # an `input[type=number]`, its currency beside
+            label += " (a number)"
         shown_when = self._shown_when(question["id"])
         required = bool(question["required"])
         unfillable = None
@@ -453,7 +456,10 @@ def _fill_question(
                     continue
                 option.click()
         case _:
-            _inputs(box, entry, question).fill(values[0])
+            target = _inputs(box, entry, question)
+            if target.get_attribute("type") == "number" and not NUMBER.fullmatch(values[0]):
+                return  # a number input holds no text: it reads back empty
+            target.fill(values[0])
 
 
 def _read_question(box: Locator, question: dict[str, Any], entry: dict[str, Any]) -> Answer | None:

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/cli.py

@@ -212,10 +212,15 @@ def _slim(result: dict, command: str | None) -> dict:
 
 
 def _sparse(value: object) -> object:
-    """Drops the keys whose value is null, false or empty, at every depth."""
+    """Drops the keys whose value is null, false or empty, at every depth; empty `options`
+    stay, nothing to choose, where null is unknown."""
     if isinstance(value, dict):
         kept = {k: _sparse(v) for k, v in value.items()}
-        return {k: v for k, v in kept.items() if v not in (None, False, [], {})}
+        return {
+            k: v
+            for k, v in kept.items()
+            if v not in (None, False, [], {}) or (k == "options" and v == [])
+        }
     if isinstance(value, list):
         return [_sparse(v) for v in value]
     return value

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/core/conditions.py

@@ -1,6 +1,6 @@
 """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
+from atsfill.core.results import AllOf, Answer, AnyOf, Condition, Field, Is, OptionSet
 
 
 def _parents(condition: Condition) -> list[str]:
@@ -24,17 +24,22 @@ def alternatives(fields: list[Field]) -> dict[str, list[Field]]:
 
 def faults(fields: list[Field]) -> list[str]:
     """What makes the fields' conditions unusable: a field they name that is not listed, a
-    field shown by its own answer through any chain, a group of alternatives with one member or
-    members disagreeing on `required`."""
+    field shown by its own answer through any chain, options that follow their own field, a
+    group of alternatives with one member or members disagreeing on `required`."""
     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)
+        for c in (f.shown_when, f.required_when, *(s.when for s in f.option_sets or []))
         if c
         for p in _parents(c)
         if p not in by_id
     ]
+    out += [
+        f"{f.id}: its options follow its own answer"
+        for f in fields
+        if any(f.id in _parents(s.when) for s in f.option_sets or [])
+    ]
 
     def loops(field_id: str, seen: tuple[str, ...]) -> bool:
         if field_id in seen:
@@ -94,6 +99,14 @@ class Form:
         when = field.required_when
         return field.required or (when is not None and self.holds(when))
 
+    def option_set(self, field: Field) -> OptionSet | None:
+        """The first of a dependent list's sets that holds under the answers."""
+        return next((s for s in field.option_sets or [] if self.holds(s.when)), None)
+
+    def options(self, field: Field) -> list[str] | None:
+        held = self.option_set(field)
+        return field.options if held is None else held.options
+
     def _value(self, field_id: str) -> Answer | None:
         field = self.by_id[field_id]
         if not self.shown(field):

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/core/matching.py

@@ -13,8 +13,16 @@ def _norm(value: str) -> str:
     return unicodedata.normalize("NFC", value).strip()
 
 
-def _in_options(field: Field, values: list[str]) -> bool:
-    return field.options is None or all(v in field.options for v in values)
+def _options(field: Field, form: Form | None) -> list[str] | None:
+    """The options an answer is one of; without the form, a dependent list's are unknown."""
+    if form is not None:
+        return form.options(field)
+    return None if field.option_sets else field.options
+
+
+def _in_options(field: Field, values: list[str], form: Form | None) -> bool:
+    options = _options(field, form)
+    return options is None or all(v in options for v in values)
 
 
 def _picked_from(answer: str, suggestion: str) -> bool:
@@ -32,14 +40,16 @@ def _absolute_url(value: str) -> bool:
     return parts.scheme in ("http", "https") and bool(parts.netloc)
 
 
-def matches(field: Field, answer: Answer, read_back: Answer | None) -> bool:
+def matches(
+    field: Field, answer: Answer, read_back: Answer | None, form: Form | None = None
+) -> bool:
     if read_back is None:
         return False
     match field.type:
         case FieldType.MULTI_CHOICE:
             a, r = [answer] if isinstance(answer, str) else answer, read_back
             r = [r] if isinstance(r, str) else r
-            return sorted(a) == sorted(r) and _in_options(field, a)
+            return sorted(a) == sorted(r) and _in_options(field, a, form)
     if not isinstance(answer, str) or not isinstance(read_back, str):
         return False
     match field.type:
@@ -48,7 +58,7 @@ def matches(field: Field, answer: Answer, read_back: Answer | None) -> bool:
         case FieldType.DATE:
             return answer == read_back
         case FieldType.CHOICE:
-            return answer == read_back and _in_options(field, [answer])
+            return answer == read_back and _in_options(field, [answer], form)
         case FieldType.TYPEAHEAD:
             return _picked_from(answer, read_back)
         case FieldType.FILE:
@@ -65,7 +75,7 @@ def check(
     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)))
+        Check(f.id, a, read_back.get(f.id), matches(f, a, read_back.get(f.id), form))
         for f_id, a in answers.items()
         if (f := by_id.get(f_id))
     ]
@@ -76,7 +86,7 @@ def check(
     ]
 
 
-def _answer_problem(field: Field, answer: object) -> str | None:
+def _answer_problem(field: Field, answer: object, form: Form) -> str | None:
     if field.type is FieldType.MULTI_CHOICE:
         if not (isinstance(answer, list) and all(isinstance(v, str) for v in answer)):
             return "a multi_choice answer is a list of strings"
@@ -85,8 +95,12 @@ def _answer_problem(field: Field, answer: object) -> str | None:
         return f"a {field.type} answer is a string"
     else:
         values = [answer]
-    if field.type in (FieldType.CHOICE, FieldType.MULTI_CHOICE) and not _in_options(field, values):
-        return f"{answer!r} is not one of {field.options}"
+    if field.type in (FieldType.CHOICE, FieldType.MULTI_CHOICE) and not _in_options(
+        field, values, form
+    ):
+        held = form.option_set(field)
+        under = f", the options when {describe(held.when, form.by_id)}" if held else ""
+        return f"{answer!r} is not one of {form.options(field)}{under}"
     length = len(_norm(values[0]))
     if (
         field.type in (FieldType.TEXT, FieldType.URL)
@@ -138,6 +152,8 @@ def problems(fields: list[Field], answers: dict[str, Answer]) -> list[str]:
     out += [
         f"{i}: {problem}"
         for i, a in answers.items()
-        if i in by_id and not by_id[i].unfillable and (problem := _answer_problem(by_id[i], a))
+        if i in by_id
+        and not by_id[i].unfillable
+        and (problem := _answer_problem(by_id[i], a, form))
     ]
     return out

{atsfill-0.0.4.dev99 → atsfill-0.0.4.dev101}/src/atsfill/core/results.py

@@ -50,6 +50,14 @@ class AllOf:
 type Condition = Is | AnyOf | AllOf
 
 
+@dataclass(frozen=True)
+class OptionSet:
+    """A dependent list's options while `when` holds; `[]` leaves nothing to choose."""
+
+    when: Condition
+    options: list[str]
+
+
 @dataclass(frozen=True)
 class Field:
     id: str
@@ -65,6 +73,7 @@ class Field:
     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
     one_of: str | None = None  # an alternative: one of the fields with this key answers (ADR 0005)
+    option_sets: list[OptionSet] | None = None  # a dependent list's; `options` where none holds
 
 
 @dataclass(frozen=True)