atsfill 0.0.4.dev49__tar.gz → 0.0.4.dev51__tar.gz

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/PKG-INFO

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

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

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

@@ -12,7 +12,7 @@ from functools import partial
 from typing import Any
 from urllib.parse import parse_qs, urlsplit
 
-from atsfill.core.adapter import Blocked, Unsupported
+from atsfill.core.adapter import Blocked, Gap, Unsupported, known_gap
 from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Response, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
@@ -67,6 +67,7 @@ def _op(response: Response) -> str:
 
 class Ashby:
     name = "ashby"
+    known_gaps = {"education_history": Gap.RENDERING}
     side_effects = [
         SideEffect(
             "fill", "hiring_system", "each answer and the resume are saved to Ashby as typed"
@@ -166,7 +167,7 @@ class Ashby:
                     self._saved(page, partial(upload.set_input_files, answer))
                 case kind, _:
                     raise Unsupported(
-                        f"unsupported_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
+                        f"unhandled_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
                     )
         self._answered = list(answers)
 
@@ -227,16 +228,20 @@ class Ashby:
             if not e.get("isHidden")
         ]
 
-    @staticmethod
-    def _field(entry: dict[str, Any]) -> Field:
+    def _field(self, entry: dict[str, Any]) -> Field:
         f = entry["field"]
+        path, title, required = f["path"], f["title"], bool(entry["isRequired"])
+        if f["type"] == "EducationHistory":
+            gap = known_gap(self, "education_history", f"{path} is a list of schools")
+            return Field(path, title, FieldType.TEXT, required, unfillable=gap)
         kind = TYPES.get(f["type"])
         if kind is None:
-            raise Unsupported(f"unsupported_rendering: {f['path']} is an Ashby {f['type']} field")
+            reason = f"unhandled_rendering: {path} is an Ashby {f['type']} field"
+            return Field(path, title, FieldType.TEXT, required, unfillable=reason)
         options = [v["label"] for v in f.get("selectableValues") or []] or None
         if f["type"] == "Boolean":
             options = ["Yes", "No"]
-        return Field(f["path"], f["title"], kind, bool(entry["isRequired"]), options)
+        return Field(path, title, kind, required, options)
 
     def _values(self) -> dict[str, Answer | None]:
         return {e["field"]["path"]: self._value(e) for e in self._entries()}

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/bamboohr.py

@@ -10,11 +10,12 @@ import json
 import re
 import urllib.request
 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, Unsupported
+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
 
@@ -140,6 +141,7 @@ _READ_BACK = """(form, specs) => {
 
 class BambooHR:
     name = "bamboohr"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("upload", "hiring_system", "an attached file is stored by BambooHR at once"),
         SideEffect("submit", "employer", "the application reaches the employer"),
@@ -186,10 +188,11 @@ class BambooHR:
         country = form.locator("select[name='countryId.value']")
         default = (_shown(country) or "") if country.count() else None
         fields = _form(detail["json"], states, default)
-        self._specs = {f.id: spec for f, spec in fields}
+        out = []
         for field, (kind, name, _) in fields:
-            if field.id.endswith("_other"):
-                continue  # shown once its question is answered Other
+            if field.unfillable or field.id.endswith("_other"):
+                out.append(field)  # an `_other` shows once its question is answered Other
+                continue
             present = (
                 form.locator("input[placeholder*=yyyy]")
                 if kind == "date"
@@ -198,8 +201,14 @@ class BambooHR:
                 else form.locator(f"[name='{name}']")
             )
             if not present.count():
-                raise Unsupported(f"unsupported_flow: {field.id} is not on the page")
-        return [f for f, _ in fields]
+                field = replace(
+                    field, unfillable=f"unhandled_rendering: {field.id} is not on the page"
+                )
+            out.append(field)
+        self._specs = {
+            f.id: spec for f, (_, spec) in zip(out, fields, strict=True) if not f.unfillable
+        }
+        return out
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         form = page.locator(FORM)
@@ -388,7 +397,12 @@ def _form(
         if not entry:  # a demographic question the employer does not ask
             continue
         if key not in STANDARD:
-            raise Unsupported(f"unsupported_rendering: {key} is a field it does not know")
+            reason = f"unhandled_rendering: {key} is a field it does not know"
+            meta = entry if isinstance(entry, dict) else {}
+            label, required = str(meta.get("label") or key).strip(), bool(meta.get("isRequired"))
+            field = Field(key, label, FieldType.TEXT, required, unfillable=reason)
+            out.append((field, ("text", None, None)))
+            continue
         kind, name = STANDARD[key]
         label, required = entry["label"].strip(), entry["isRequired"]
         options = [o["text"] for o in entry.get("options") or []] or None
@@ -417,11 +431,13 @@ def _states(states: dict[str, Any], default: str | None) -> list[str]:
 
 def _custom(question: dict[str, Any]) -> list[tuple[Field, tuple[str, str | None, Any]]]:
     qid, kind_api = question["id"], question["type"]
+    label, required = question["question"].strip(), question["isRequired"]
     if kind_api not in CUSTOM:
-        raise Unsupported(f"unsupported_rendering: question {qid} is a {kind_api}")
+        reason = f"unhandled_rendering: question {qid} is a {kind_api}"
+        field = Field(f"question_{qid}", label, FieldType.TEXT, required, unfillable=reason)
+        return [(field, ("text", None, None))]
     kind = CUSTOM[kind_api]
     name = f"customQuestionAnswers.{kind_api}_{qid}"
-    label, required = question["question"].strip(), question["isRequired"]
     options, extra = None, None
     if kind_api == "yes_no" or kind == "checkbox":
         options = YES_NO

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/breezy.py

@@ -13,7 +13,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
-from atsfill.core.adapter import Unsupported
+from atsfill.core.adapter import Gap, Unsupported, out_of_scope
 from atsfill.core.browser import Locator, Page, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
@@ -95,7 +95,7 @@ ENTRIES = {
 }
 
 # The fields in page order, one per control name, with its heading's text and how it renders;
-# a question the adapter cannot fill is kept as its kind, to be refused when required.
+# a live video question is kept as the kind `video`.
 _READ = """form => {
   const text = el => {
     if (!el) return "";
@@ -210,6 +210,7 @@ _FILE_SHOWN = """e => {
 
 class Breezy:
     name = "breezy"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("upload", "hiring_system", "an attached file is uploaded to Breezy at once"),
         SideEffect("submit", "employer", "the application reaches the employer"),
@@ -242,8 +243,9 @@ class Breezy:
             raise Unsupported("posting_gone: no application form on the page") from None
         fields, self._kinds = [], {}
         for raw in form.evaluate(_READ):
-            if (field := _field(raw)) is not None:
-                fields.append(field)
+            field = _field(raw)
+            fields.append(field)
+            if not field.unfillable:
                 self._kinds[field.id] = raw["kind"]
         return fields + self._entries(form)
 
@@ -341,13 +343,11 @@ class Breezy:
         return f"{response.url} {response.status}"
 
 
-def _field(raw: dict[str, Any]) -> Field | None:
-    """The field, or None for one the page asks optionally and atsfill cannot fill."""
+def _field(raw: dict[str, Any]) -> Field:
     kind = raw["kind"]
     if kind == "video":
-        if raw["required"]:
-            raise Unsupported(f"unsupported_rendering: {raw['label']!r} asks for a recorded video")
-        return None
+        reason = out_of_scope(raw["id"], "a video recorded live")
+        return Field(raw["id"], raw["label"], FieldType.FILE, raw["required"], unfillable=reason)
     label = LABELS.get(raw["id"]) or raw.get("label", "")
     if "part" in raw:
         label = (

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/dayforce.py

@@ -16,7 +16,7 @@ from contextlib import suppress
 from typing import Any
 from urllib.parse import urlsplit
 
-from atsfill.core.adapter import Unsupported
+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
 
@@ -167,6 +167,7 @@ _CLICK = """([selector, n, text]) => {
 
 class Dayforce:
     name = "dayforce"
+    known_gaps = {"references": Gap.RENDERING}
     side_effects = [
         SideEffect(
             "load",
@@ -212,8 +213,8 @@ class Dayforce:
                 accepted = [f".{a.strip()}" for a in accept.split(",") if a.strip()] or None
                 fields[i] = _with(field, accept=accepted)
         for prefix, _ in ENTRIES.values():  # an entry's controls show once it is added
-            texts = [i for i, f in enumerate(fields)
-                     if f.id.startswith(f"{prefix}.") and f.type is FieldType.TEXT]  # fmt: skip
+            texts = [i for i, f in enumerate(fields) if f.id.startswith(f"{prefix}.")
+                     and f.type is FieldType.TEXT and not f.unfillable]  # fmt: skip
             if texts and page.locator(f"[test-id=add-{prefix.lower()}-record]").count():
                 base = _open_entry(page, prefix)
                 for i in texts:
@@ -280,8 +281,9 @@ class Dayforce:
         for f in _visible(personal):
             key, kind = PERSONAL_FIELDS.get(f["fieldName"], (None, None))
             if key is None or kind is None:
-                if f["isRequired"]:
-                    raise Unsupported(f"unsupported_rendering: personal field {f['fieldName']!r}")
+                reason = f"unhandled_rendering: personal field {f['fieldName']!r}"
+                fields.append(Field(f["fieldName"], f["displayName"], FieldType.TEXT,
+                                    bool(f["isRequired"]), unfillable=reason))  # fmt: skip
                 continue
             options = {
                 "candidateSource": sources,
@@ -316,14 +318,17 @@ class Dayforce:
             ]
         for section in sections:
             ref = section.get("xRefCode")
-            if (
-                not section.get("questionnaire")
-                and ref not in CANDIDATE_INFO
-                and section.get("isRequired")
-            ):
-                raise Unsupported(
-                    f"unsupported_rendering: {section['displayName']!r} section is required"
-                )
+            if section.get("questionnaire") or ref in CANDIDATE_INFO:
+                continue
+            name = section["displayName"]
+            if ref == "REFERENCES":
+                field_id = "references"
+                reason = known_gap(self, "references", f"{name!r} needs references added")
+            else:
+                field_id = f"section.{ref}"
+                reason = f"unhandled_rendering: {name!r} section {ref}"
+            fields.append(Field(field_id, name, FieldType.TEXT, bool(section.get("isRequired")),
+                                unfillable=reason))  # fmt: skip
         self._sections = [
             s for s in sections if s.get("questionnaire") and s.get("xRefCode") != "SUBMIT"
         ]
@@ -407,7 +412,9 @@ class Dayforce:
     def _fill_entry(self, page: Page, prefix: str, answers: dict[str, Answer]) -> None:
         """Adds one entry to a history section and fills it."""
         base = _open_entry(page, prefix)
-        fields = [f for f in self._fields.values() if f.id.startswith(f"{prefix}.")]
+        fields = [
+            f for f in self._fields.values() if f.id.startswith(f"{prefix}.") and not f.unfillable
+        ]
         for field in fields:
             if field.id in answers:
                 _fill_control(page, _id(base + field.id.split(".")[1]), field, answers[field.id])
@@ -432,7 +439,7 @@ class Dayforce:
     ) -> None:
         field_id = f"q{question['questionId']}"
         field = self._fields.get(field_id)
-        if field is None:
+        if field is None or field.unfillable:
             return
         target = _question_target(page, base, question)
         if target is None:
@@ -549,13 +556,14 @@ def _entry_fields(
     fields = []
     for f in _visible(section):
         key, kind = keys.get(re.sub(r"\s", "", f["fieldName"]).upper(), (None, None))
+        required = bool(f["isRequired"] and section["isRequired"])
+        label = f"{section['displayName']}: {f['displayName']}"
         if key is None or kind is None:
-            if f["isRequired"] and section["isRequired"]:
-                raise Unsupported(f"unsupported_rendering: {prefix} field {f['fieldName']!r}")
+            reason = f"unhandled_rendering: {prefix} field {f['fieldName']!r}"
+            field_id = f"{prefix}.{f['fieldName']}"
+            fields.append(Field(field_id, label, FieldType.TEXT, required, unfillable=reason))
             continue
-        required = bool(f["isRequired"] and section["isRequired"])
         options = NO_YES if kind == "boolean" else None
-        label = f"{section['displayName']}: {f['displayName']}"
         fields.append(Field(f"{prefix}.{key}", label, ENTRY_KINDS[kind], required, options))
     return fields
 
@@ -594,13 +602,11 @@ def _question_fields(section: dict[str, Any], question: dict[str, Any]) -> list[
     label = _plain(question.get("description") or "")
     if not label or len(label) > LONG_LABEL:
         label = _plain(question["displayName"])
-    if kind is None:
-        if question["isRequired"]:
-            raise Unsupported(
-                f"unsupported_rendering: {label!r} has answer type {question['answerType']}"
-            )
-        return []
     field_id = f"q{question['questionId']}"
+    if kind is None:
+        reason = f"unhandled_rendering: {field_id} has answer type {question['answerType']}"
+        required = bool(question["isRequired"])
+        return [Field(field_id, label, FieldType.TEXT, required, unfillable=reason)]
     options = None
     if question["answerType"] == CHECKBOX:
         options = YES_NO

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/greenhouse.py

@@ -14,7 +14,7 @@ from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit
 
 from atsfill.core import browser
-from atsfill.core.adapter import Unsupported
+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
 
@@ -120,6 +120,7 @@ _READ_BACK = """(form, ids) => {
 
 class Greenhouse:
     name = "greenhouse"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("upload", "hiring_system", "an attached file is stored by Greenhouse at once"),
         SideEffect("submit", "employer", "the application reaches the employer"),
@@ -242,7 +243,10 @@ class Greenhouse:
                 else:
                     field_type = FieldType.MULTI_CHOICE if kind == "multi" else FieldType.CHOICE
             case _:  # a radio input, not seen on a posting yet
-                raise Unsupported(f"unsupported_rendering: {raw['id']} is a {kind}")
+                reason = f"unhandled_rendering: {raw['id']} is a {kind}"
+                return Field(
+                    raw["id"], raw["label"], FieldType.TEXT, raw["required"], unfillable=reason
+                )
         return Field(
             raw["id"],
             raw["label"],

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/hireology.py

@@ -11,11 +11,12 @@ import json
 import re
 import urllib.request
 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 Unsupported
+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
 
@@ -187,6 +188,7 @@ _READ_BACK = """(form, kinds) => {
 
 class Hireology:
     name = "hireology"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [SideEffect("submit", "employer", "the application reaches the employer")]
 
     def __init__(self) -> None:
@@ -218,13 +220,15 @@ class Hireology:
         api = page.evaluate(_FETCH, API.format(job=job))
         if "status" in api:
             raise Unsupported(f"posting_gone: the form API answered {api['status']}")
-        form = _form(api["json"])
-        self._kinds = {field.id: kind for field, kind in form}
-        form_el = page.locator(FORM)
-        for field, _ in form:
-            if field.id not in SHOWN_BY and form_el.evaluate(_CONTROL, field.id) is None:
-                raise Unsupported(f"unsupported_flow: {field.id} is not on the page")
-        return [f for f, _ in form]
+        form_el, out = page.locator(FORM), []
+        for field, kind in _form(api["json"]):
+            skip = field.unfillable or field.id in SHOWN_BY
+            if not skip and form_el.evaluate(_CONTROL, field.id) is None:
+                reason = f"unhandled_rendering: {field.id} is not on the page"
+                field = replace(field, unfillable=reason)
+            out.append((field, kind))
+        self._kinds = {field.id: kind for field, kind in out if not field.unfillable}
+        return [f for f, _ in out]
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         form = page.locator(FORM)
@@ -303,14 +307,17 @@ def _form(api: dict[str, Any]) -> list[tuple[Field, str]]:
 def _field(entry: dict[str, Any], section: str) -> Field:
     field_id, attributes = entry["id"], entry["attributes"]
     kind = attributes["type"]
-    if kind not in TYPES:
-        raise Unsupported(f"unsupported_rendering: {field_id} is a {kind}")
     label = (
         section
         + (
             LABELS.get(field_id) or attributes.get("label") or entry.get("label") or field_id
         ).strip()
     )
+    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
+        )
     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":

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/jazzhr.py

@@ -12,7 +12,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
-from atsfill.core.adapter import Blocked, Unsupported
+from atsfill.core.adapter import Blocked, Gap, Unsupported
 from atsfill.core.browser import Page, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
@@ -122,6 +122,7 @@ _READ_BACK = """(form, fields) => {
 
 class JazzHR:
     name = "jazzhr"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [SideEffect("submit", "employer", "the application reaches the employer")]
 
     def __init__(self) -> None:
@@ -238,7 +239,10 @@ def _field(raw: dict[str, Any]) -> Field:
         case "consent":
             field_type, options = FieldType.CHOICE, YES_NO
         case _:
-            raise Unsupported(f"unsupported_rendering: {raw['id']} is a {kind}")
+            reason = f"unhandled_rendering: {raw['id']} is a {kind}"
+            return Field(
+                raw["id"], raw["label"], FieldType.TEXT, raw["required"], unfillable=reason
+            )
     accept = RESUME_TYPES if kind == "file" else None
     return Field(
         raw["id"], raw["label"], field_type, raw["required"], options, raw.get("maxLength"), accept

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/lever.py

@@ -12,7 +12,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
-from atsfill.core.adapter import Blocked, Unsupported
+from atsfill.core.adapter import Blocked, Gap, Unsupported
 from atsfill.core.browser import Locator, Page, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
 
@@ -117,6 +117,7 @@ _READ_BACK = """(form, kinds) => {
 
 class Lever:
     name = "lever"
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("upload", "hiring_system", "the resume is uploaded to Lever and parsed at once"),
         SideEffect("submit", "employer", "the application reaches the employer"),
@@ -205,7 +206,8 @@ def _job(url: str) -> tuple[str, str] | None:
 def _field(raw: dict[str, Any]) -> Field:
     kind = raw["kind"]
     if kind not in KINDS:
-        raise Unsupported(f"unsupported_rendering: {raw['id']} is a {kind}")
+        reason = f"unhandled_rendering: {raw['id']} is a {kind}"
+        return Field(raw["id"], raw["label"], FieldType.TEXT, raw["required"], unfillable=reason)
     options = {"consent": YES_NO, "select": raw["options"]}.get(kind)
     if kind in ("radio", "checkboxes"):
         options = raw["options"]

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/manatal.py

@@ -11,7 +11,7 @@ from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlsplit
 
-from atsfill.core.adapter import Blocked, Unsupported
+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
 
@@ -33,7 +33,7 @@ LISTS: dict[str, tuple[str, Callable[[dict[str, Any]], str]]] = {
     "languages": ("languages/", lambda n: n["name"]),
     "industries": ("clients/{client}/industries/", lambda n: n["name"]),
 }
-ENTRIES = ("educations", "experiences")  # a sub-form of entries: left out when optional
+ENTRIES = ("educations", "experiences")  # a sub-form of entries
 SHORT = {"full_name", "email", "phone_number", "city", "address", "latest_degree",
          "latest_university", "current_company", "current_department", "current_position",
          "current_benefits", "expected_benefits", "skype", "contact"}  # fmt: skip
@@ -106,15 +106,11 @@ def _kind(entry: dict[str, Any]) -> str:
     return "text"
 
 
-def _field(entry: dict[str, Any], options: list[str] | None) -> Field | None:
-    """The field an entry of the endpoint lists, None for optional entries."""
+def _field(entry: dict[str, Any], options: list[str] | None) -> Field:
+    """The field an entry of the endpoint lists, a sub-form of entries aside."""
     kind, slug = _kind(entry), entry["client_field_slug"]
     fid, label, required = str(entry["id"]), entry["label"], bool(entry["is_required"])
     match kind:
-        case "entries" if required:
-            raise Unsupported(f"unsupported_rendering: {entry['field_type']} entries are required")
-        case "entries":
-            return None
         case "file":
             accept = RESUME_TYPES if entry["field_type"] == "resume" else None
             return Field(fid, label, FieldType.FILE, required, accept=accept)
@@ -157,6 +153,7 @@ def _options(entry: dict[str, Any], client: str) -> list[str] | None:
 
 class Manatal:
     name = "manatal"
+    known_gaps = {"entries": Gap.RENDERING}
     side_effects = [
         SideEffect("submit", "hiring_system", "the resume and attachments are uploaded"),
         SideEffect("submit", "employer", "the application reaches the employer"),
@@ -185,7 +182,7 @@ class Manatal:
             entries = _get(f"jobs/{job.group(1)}/application-form/")
             terms = bool(TERMS_REQUIRED.search(html))
             return self._fields(entries, terms, lambda e: _options(e, client))
-        except OSError, ValueError, KeyError, TypeError, Unsupported:
+        except OSError, ValueError, KeyError, TypeError:
             return None
 
     def read_form(self, page: Page) -> list[Field]:
@@ -245,7 +242,7 @@ class Manatal:
                     named.evaluate(_CHECK, answer == "Yes")
                 case kind, _:
                     raise Unsupported(
-                        f"unsupported_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
+                        f"unhandled_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
                     )
 
     def read_back(self, page: Page) -> dict[str, Answer]:
@@ -274,11 +271,22 @@ class Manatal:
         terms: bool,
         options: Callable[[dict[str, Any]], list[str] | None],
     ) -> list[Field]:
-        fields = [f for e in entries if (f := _field(e, options(e))) is not None]
+        fields = [
+            self._entries_field(e) if _kind(e) == "entries" else _field(e, options(e))
+            for e in entries
+        ]
         if terms:
             fields.append(Field(TERMS, TERMS_LABEL, FieldType.CHOICE, True, YES_NO))
         return fields
 
+    def _entries_field(self, entry: dict[str, Any]) -> Field:
+        """An "Add Education" or "Add Experience" sub-form of entries."""
+        fid = str(entry["id"])
+        gap = known_gap(self, "entries", f"{fid} is a list of {entry['field_type']}")
+        return Field(
+            fid, entry["label"], FieldType.TEXT, bool(entry["is_required"]), unfillable=gap
+        )
+
     @staticmethod
     def _shown(page: Page, entry: dict[str, Any]) -> list[str] | None:
         """The options the page shows for a choice, without the empty placeholder."""

{atsfill-0.0.4.dev49 → atsfill-0.0.4.dev51}/src/atsfill/adapters/oracle.py

@@ -16,7 +16,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser, matching
-from atsfill.core.adapter import Blocked, NotTaken, Unsupported
+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
 
@@ -230,6 +230,7 @@ _READ_BACK = """(ids) => {
 
 class Oracle:
     name = "oracle"
+    known_gaps = {"entries": Gap.RENDERING}
     side_effects = [
         SideEffect(
             "load",
@@ -358,10 +359,10 @@ class Oracle:
         except browser.Timeout:
             if page.locator(CAPTCHA).count():
                 raise Blocked("captcha: the email step asks for an hCaptcha") from None
-            raise Unsupported("unsupported_flow: the email step did not open the form") from None
+            raise RuntimeError("the email step did not open the form") from None
         if page.locator(CODE_PAGE).count():
             raise Blocked(
-                f"emailed_code: {email} is known to this employer's Oracle, which emails it a"
+                f"email_code: {email} is known to this employer's Oracle, which emails it a"
                 " code before it shows the form"
             )
         page.locator(f"{PAGINATION}:visible").first.wait_for(timeout=STEP_TIMEOUT_MS)
@@ -370,9 +371,8 @@ class Oracle:
     def _described(self, page: Page, raw: dict[str, Any]) -> Field | None:
         """The field a raw description is, None for one atsfill leaves out."""
         if raw["kind"] == "tiles":
-            if raw["required"]:
-                raise Unsupported(f"unsupported_rendering: {raw['label']!r} needs entries added")
-            return None
+            gap = known_gap(self, "entries", f"{raw['label']!r} needs entries added")
+            return Field(raw["id"], raw["label"], FieldType.TEXT, raw["required"], unfillable=gap)
         if raw["kind"] == "email":
             self._kinds[EMAIL] = "email"
             return None
@@ -388,7 +388,7 @@ class Oracle:
         """The innermost row holding the field."""
         selector = page.evaluate(_ROW, field_id)
         if selector is None:
-            raise Unsupported(f"unsupported_flow: {field_id} left the form while it was filled")
+            raise RuntimeError(f"{field_id} left the form while it was filled")
         return page.locator(".input-row").filter(has=page.locator(selector)).last
 
     def _options(self, page: Page, field_id: str) -> list[str]:
@@ -455,7 +455,7 @@ class Oracle:
                 _choose(page, boxes.nth(2), year, exact=True)
             case _:
                 raise Unsupported(
-                    f"unsupported_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
+                    f"unhandled_rendering: cannot fill {field_id}, a {kind}, with {answer!r}"
                 )
 
     def _phone(self, page: Page, row: Locator, answer: str) -> None:
@@ -543,7 +543,7 @@ def _go_to(page: Page, number: int) -> None:
             )
             _settle(page)
             return
-    raise Unsupported(f"unsupported_flow: page {number} of the form did not open")
+    raise RuntimeError(f"page {number} of the form did not open")
 
 
 def _upload(field_id: str) -> str: