atsfill 0.0.8.dev223__tar.gz → 0.0.8.dev224__tar.gz

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.8.dev223
+Version: 0.0.8.dev224
 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.8.dev223 → atsfill-0.0.8.dev224}/pyproject.toml

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

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.8.dev223"
+version = "0.0.8.dev224"
 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.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/adp.py

@@ -584,8 +584,12 @@ def _wait_for_step(page: Page, step: Step) -> None:
 
 
 def _next(page: Page, step: Step) -> None:
-    """Next, once the step is left; the page's errors where it stays."""
-    page.locator(NEXT).click()
+    """Next, once the step is left; the page's errors where it stays. It is disabled while a
+    résumé uploads, past the moment the step lists the file."""
+    try:
+        page.locator(NEXT).click(timeout=UPLOAD_TIMEOUT_MS)
+    except Timeout:
+        raise NotTaken(f"{step.name}: Next stayed disabled: {_errors(page)}") from None
     deadline = time.monotonic() + STEP_TIMEOUT_MS / 1000
     while step.marker and page.locator(step.marker).first.count():
         if time.monotonic() > deadline:

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/eightfold.py

@@ -241,6 +241,15 @@ class Eightfold:
                     continue
             _fill(page, control, answer)
             given[control.field.id] = answer
+        self._again(page, given)
+
+    def _again(self, page: Page, given: dict[str, Answer]) -> None:
+        """Fills once more an answered control a later render emptied."""
+        placed = [c for c in self._controls if c.dom and given.get(c.field.id)]
+        values = self._values(page, placed)
+        for control in placed:
+            if not values.get(control.field.id):
+                _fill(page, control, given[control.field.id])
 
     def shown_fields(self, page: Page) -> list[str]:
         """The questions rendered once filled, each control's by the longest question id its

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/gupy.py

@@ -77,7 +77,7 @@ _READ_ADDITIONAL = """() => {
 }"""
 
 # The employer's questions, by question id: the checked labels, or the text typed.
-_READ_QUESTIONS = """(ids) => Object.fromEntries(ids.map(([id, title]) => {
+_READ_QUESTIONS = """(ids) => Object.fromEntries(ids.map(([id, title, nth]) => {
   const radios = [...document.querySelectorAll(`input[name="question-${id}"]`)];
   const boxes = [...document.querySelectorAll(`input[name^="checkbox-${id}-"]`)];
   const picked = [...radios, ...boxes].filter(e => e.checked)
@@ -85,7 +85,7 @@ _READ_QUESTIONS = """(ids) => Object.fromEntries(ids.map(([id, title]) => {
   if (boxes.length) return [`question-${id}`, picked];
   if (radios.length) return [`question-${id}`, picked[0] ?? null];
   const text = [...document.querySelectorAll("textarea, input[type=text]")]
-    .find(e => e.name === title || e.id === `input-${title}`);
+    .filter(e => e.name === title || e.id === `input-${title}`)[nth];
   return [`question-${id}`, text?.value ?? null];
 }))"""
 
@@ -228,16 +228,25 @@ class Gupy:
         page.locator(QUESTIONS).first.wait_for(timeout=SAVE_TIMEOUT_MS)
         for field_id, answer in answers.items():
             if (question := self._questions.get(field_id)) is not None:
-                _answer(page, self._fields[field_id], question, answer)
+                _answer(page, self._fields[field_id], question, answer, self._nth(field_id))
 
-    def shown_fields(self, page: Page) -> list[str]:
-        """Additional information as it was saved, and the questions the page renders: a text
-        is known only by its title, which questions can share."""
+    def _by_title(self) -> dict[str, list[str]]:
+        """A text is known only by its title, which questions can share: the page's controls of
+        one title are taken as its questions, the answered ones first."""
         by_title: dict[str, list[str]] = {}
         for field_id, question in self._questions.items():
             by_title.setdefault(question["title"], []).append(field_id)
         for ids in by_title.values():
             ids.sort(key=lambda i: i not in self._given)
+        return by_title
+
+    def _nth(self, field_id: str) -> int:
+        """Which of the controls titled as its question is this field's."""
+        return self._by_title()[self._questions[field_id]["title"]].index(field_id)
+
+    def shown_fields(self, page: Page) -> list[str]:
+        """Additional information as it was saved, and the questions the page renders."""
+        by_title = self._by_title()
         shown = list(self._additional_shown)
         for control in page.evaluate(_SHOWN_QUESTIONS) if page.locator(QUESTIONS).count() else []:
             ids = by_title.get(control.removeprefix("input-"))
@@ -252,7 +261,7 @@ class Gupy:
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Additional information as it was saved, or as the page holds it; the questions'."""
         additional = self._additional or self._read_additional(page)
-        ids = [[q["questionId"], q["title"]] for q in self._questions.values()]
+        ids = [[q["questionId"], q["title"], self._nth(i)] for i, q in self._questions.items()]
         values = page.evaluate(_READ_QUESTIONS, ids) if page.locator(QUESTIONS).count() else {}
         return {**additional, **{k: v for k, v in values.items() if v not in (None, "", [])}}
 
@@ -346,7 +355,7 @@ def _set(page: Page, field: Field, field_id: str, answer: Answer) -> None:
             raise Unsupported(f"unhandled_rendering: cannot fill {field_id}, a {kind}")
 
 
-def _answer(page: Page, field: Field, question: dict[str, Any], answer: Answer) -> None:
+def _answer(page: Page, field: Field, question: dict[str, Any], answer: Answer, nth: int) -> None:
     qid = question["questionId"]
     match field.type, answer:
         case FieldType.CHOICE, str():
@@ -361,7 +370,7 @@ def _answer(page: Page, field: Field, question: dict[str, Any], answer: Answer)
             target = page.locator(f'textarea[name="{_css(title)}"], input[name="{_css(title)}"]')
             if not target.count():
                 target = page.locator(f'[id="input-{_css(title)}"]')
-            target.first.fill(answer)
+            target.nth(nth).fill(answer)
         case kind, _:
             raise Unsupported(f"unhandled_rendering: cannot fill question-{qid}, a {kind}")
 

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/jobaffinity.py

@@ -17,7 +17,7 @@ from urllib.parse import parse_qs, urljoin, urlsplit
 
 from atsfill.core import html
 from atsfill.core.adapter import Gap, Unsupported, known_gap
-from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Timeout
+from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Timeout, machine_locale
 from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 ORIGIN = "https://jobaffinity.fr"
@@ -32,6 +32,7 @@ UPLOAD_TIMEOUT_MS = 30_000
 ANALYSIS_TIMEOUT_MS = 30_000
 SUBMIT_TIMEOUT_MS = 90_000
 YES_NO = ["Yes", "No"]
+BROWSER_LANGUAGE = "en-US"  # what the browser sends on a machine with no locale
 CONSENT = "gdpr_agreement"
 AVAILABILITY, AVAILABLE_FROM, FROM_DATE = "availability", "availability_date", "date"
 DMY = "JJ/MM/AAAA"  # the hint under the older form's text date input
@@ -223,7 +224,10 @@ def _token(url: str) -> str | None:
 
 
 def _get(url: str) -> str:
-    request = urllib.request.Request(url, headers={"User-Agent": "atsfill"})
+    """The page as the browser gets it: the server localizes the country list."""
+    language = machine_locale() or BROWSER_LANGUAGE
+    headers = {"User-Agent": "atsfill", "Accept-Language": language}
+    request = urllib.request.Request(url, headers=headers)
     with urllib.request.urlopen(request, timeout=HTTP_TIMEOUT_S) as response:
         return response.read().decode()
 

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/paycor.py

@@ -14,7 +14,7 @@ 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.browser import Locator, Page, Timeout
 from atsfill.core.results import Answer, Field, FieldType, Is, OptionSet, SideEffect
 
 HOST = "recruitingbypaycor.com"
@@ -43,6 +43,7 @@ KINDS = {
 }
 STEPS = 6  # pages before the form: the EEO introduction, its two pages, the questions
 PAGE_TIMEOUT_MS = 30_000
+CONTROL_TIMEOUT_MS = 10_000  # a radio stays disabled until the answer it hangs on is taken
 UPLOAD_TIMEOUT_MS = 60_000
 SUBMIT_TIMEOUT_MS = 90_000
 
@@ -255,11 +256,7 @@ class Paycor:
                 case "select", str():
                     named.select_option(label=answer)
                 case "radio", str():
-                    named.first.wait_for(state="attached")
-                    page.wait_for_function(
-                        "n => [...document.getElementsByName(n)].some(e => !e.disabled)",
-                        arg=field.id,
-                    )
+                    self._until_enabled(page, named, field.id)
                     self._pick(named, field, [answer])
                 case "checkbox", list():
                     self._pick(named, field, answer)
@@ -268,6 +265,20 @@ class Paycor:
                         f"unhandled_rendering: cannot fill {field.id}, a {kind}, with {answer!r}"
                     )
 
+    def _until_enabled(self, page: Page, radios: Locator, field_id: str) -> None:
+        """Waits for a radio group the page enables on an earlier answer: the opt-in, on a phone
+        it takes."""
+        try:
+            radios.first.wait_for(state="attached", timeout=CONTROL_TIMEOUT_MS)
+            page.wait_for_function(
+                "n => [...document.getElementsByName(n)].some(e => !e.disabled)",
+                arg=field_id,
+                timeout=CONTROL_TIMEOUT_MS,
+            )
+        except Timeout:
+            detail = f"{field_id} stays disabled: the page refused an answer before it"
+            raise NotTaken(detail) from None
+
     def shown_fields(self, page: Page) -> list[str]:
         """The form's controls; the answers to the pages before it are hidden inputs by now."""
         return [c["id"] for c in page.evaluate(_CONTROLS)]

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/rippling.py

@@ -214,8 +214,8 @@ class Rippling:
             return None
 
     def browser_read(self, page: Page) -> list[Field]:
-        job = _job(page.url)
-        assert job is not None
+        if (job := _job(page.url)) is None:  # a closed posting redirects to its board
+            raise Unsupported(f"posting_gone: redirected to {page.url}")
         apply = APPLY.format(board=job[0], job=job[1])
         if urlsplit(page.url).path != urlsplit(apply).path:
             page.goto(apply)

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/ukg.py

@@ -514,7 +514,7 @@ def _field(raw: dict[str, Any], states: dict[str, list[str]] | None) -> Field:
     if kind == "file":
         return Field(field_id, label, FieldType.FILE, raw["required"], accept=raw["accept"])
     if raw.get("readonly"):  # the account's name, changed on its profile only
-        reason = f"unsupported_rendering: {field_id} is read-only" if not value else None
+        reason = f"unsupported_rendering: {field_id} is read-only"
         return Field(field_id, label, KINDS[kind], raw["required"], prefilled=value,
                      unfillable=reason)  # fmt: skip
     options = raw["options"] if kind in ("select", "radio") else None

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/adapters/workable.py

@@ -28,6 +28,7 @@ UPLOADED = "[data-action=delete]"  # an uploading file shows its name and an abo
 FORM_TIMEOUT_MS = 30_000
 OPTIONS_TIMEOUT_MS = 5_000
 CHECK_TIMEOUT_MS = 3_000
+CHECK_CLICKS = 3  # a form can lose a click on an option
 UPLOAD_TIMEOUT_MS = 30_000
 SUBMIT_TIMEOUT_MS = 90_000
 KEY_DELAY_MS = 20
@@ -361,16 +362,18 @@ def _pick(page: Page, field: Locator, role: str, value: str) -> None:
 
 
 def _check(option: Locator, checked: bool) -> None:
-    """Clicks a radio or checkbox unless it already is `checked`. Its `aria-checked` is the
-    form's state: the hidden input it holds is remounted, and catches up, on a later render."""
+    """Clicks a radio or checkbox unless it already is `checked`, again where the form lost the
+    click, as it can the first of a page. Its `aria-checked` is the form's state: the hidden
+    input it holds is remounted, and catches up, on a later render."""
     state = "true" if checked else "false"
-    if option.get_attribute("aria-checked") == state:
-        return
-    browser.click(option)
-    with suppress(Timeout):
-        option.and_(option.page.locator(f"[aria-checked={state}]")).wait_for(
-            timeout=CHECK_TIMEOUT_MS
-        )
+    for _ in range(CHECK_CLICKS):
+        if option.get_attribute("aria-checked") == state:
+            return
+        browser.click(option)
+        with suppress(Timeout):
+            option.and_(option.page.locator(f"[aria-checked={state}]")).wait_for(
+                timeout=CHECK_TIMEOUT_MS
+            )
 
 
 def _options(page: Page, field_id: str) -> list[str]:

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/cli.py

@@ -240,7 +240,7 @@ def emit(
 def _slim(result: dict, command: str | None) -> dict:
     """A form command's result without what the consumer already has: the URL it passed and,
     after `read`, the fields, the side effects and each answer it gave."""
-    del result["url"]
+    del result["url"], result["refused"]
     if command != "read":
         del result["fields"], result["side_effects"]
         result["checks"] = [

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/core/commands.py

@@ -354,6 +354,12 @@ def _shown_as_listed(
         result.reason = f"mismatch: {', '.join(wrong)} shows though its condition is unmet"
 
 
+def _refuse(result: Result, problems: list[matching.Problem], *more: str) -> None:
+    result.status = Status.REFUSED
+    result.reason = "invalid_answers: " + "; ".join([*problems, *more])
+    result.refused = [f"{p.field_id}: {p.rule}" for p in problems]
+
+
 def _no_field(result: Result, answers: dict[str, Answer]) -> bool:
     """Refuses an answer to no listed field. Ids come from `read`, so it says as much about the
     adapter as about the answers: a form that changed, or a field read missed."""
@@ -376,8 +382,11 @@ def _revealed(
         if _unfillable(result, mine):
             return mine
         if problems := matching.problems(result.fields, mine):
-            problems += [f"{f.id} takes {f.options}" for f in new if f.options and f.id not in mine]
-            result.status, result.reason = Status.REFUSED, "invalid_answers: " + "; ".join(problems)
+            _refuse(
+                result,
+                problems,
+                *[f"{f.id} takes {f.options}" for f in new if f.options and f.id not in mine],
+            )
             return mine
         left = [f for f in new if f.id not in mine]
         result.warnings += [f"an answer showed {f.id} ({f.label}), left empty" for f in left]
@@ -459,7 +468,7 @@ def _fill(
             return result
         given = matching.as_listed(result.fields, given)
         if problems := matching.problems(result.fields, given):
-            result.status, result.reason = Status.REFUSED, "invalid_answers: " + "; ".join(problems)
+            _refuse(result, problems)
             return result
         result.warnings = matching.knockouts(result.fields, given)
         adapter.fill(page, matching.to_fill(result.fields, given))
@@ -695,7 +704,7 @@ def _save_profile(
             result.status, result.reason = step_result.status, step_result.reason
             return
         if problems := matching.problems(fields, mine):
-            result.status, result.reason = Status.REFUSED, "invalid_answers: " + "; ".join(problems)
+            _refuse(result, problems)
             return
         checks = matching.check(fields, mine, adapter.profile_read_back(page))
         if not all(c.match for c in checks):

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/core/matching.py

@@ -3,6 +3,7 @@
 import re
 import unicodedata
 from pathlib import Path, PurePath
+from typing import Self
 from urllib.parse import urlsplit
 
 from atsfill.core.conditions import Form, describe
@@ -10,6 +11,19 @@ from atsfill.core.countries import ALPHA_3
 from atsfill.core.results import Answer, Check, Field, FieldType
 
 
+class Problem(str):
+    """What refuses an answer, in words that can quote it. `field_id` and `rule` never do: the
+    id is a listed field's and the rule one of this module's, so telemetry can carry them."""
+
+    field_id: str
+    rule: str
+
+    def __new__(cls, field_id: str, rule: str, text: str) -> Self:
+        problem = super().__new__(cls, text)
+        problem.field_id, problem.rule = field_id, rule
+        return problem
+
+
 def _norm(value: str) -> str:
     return unicodedata.normalize("NFC", value).strip()
 
@@ -97,15 +111,18 @@ def check(
     ]
 
 
-def _answer_problem(field: Field, answer: object, form: Form) -> str | None:
+def _answer_problem(field: Field, answer: object, form: Form) -> tuple[str, str] | None:
+    """The rule an answer breaks, and how."""
     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"
+            return "shape", "a multi_choice answer is a list of strings"
         if not answer:
-            return "required, so an empty list does not answer it" if form.asked(field) else None
+            if form.asked(field):
+                return "missing", "required, so an empty list does not answer it"
+            return None
         values = answer
     elif not isinstance(answer, str):
-        return f"a {field.type} answer is a string"
+        return "shape", f"a {field.type} answer is a string"
     else:
         values = [answer]
     if field.type in (FieldType.CHOICE, FieldType.MULTI_CHOICE) and not _in_options(
@@ -113,26 +130,26 @@ def _answer_problem(field: Field, answer: object, form: Form) -> str | None:
     ):
         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}"
+        return "not_an_option", f"{answer!r} is not one of {form.options(field)}{under}"
     length = len(_norm(values[0]))
     if (
         field.type in (FieldType.TEXT, FieldType.URL)
         and field.max_length
         and length > field.max_length
     ):
-        return f"{length} characters, over the limit of {field.max_length}"
+        return "too_long", f"{length} characters, over the limit of {field.max_length}"
     if field.type is FieldType.TEXT and field.min_length and length < field.min_length:
-        return f"{length} characters, under the minimum of {field.min_length}"
+        return "too_short", f"{length} characters, under the minimum of {field.min_length}"
     if field.type is FieldType.URL and not _absolute_url(values[0]):
-        return "a url answer is an absolute http(s) URL"
+        return "shape", "a url answer is an absolute http(s) URL"
     if field.type is FieldType.DATE and not re.fullmatch(r"\d{4}-\d{2}-\d{2}", values[0]):
-        return "a date answer is YYYY-MM-DD"
+        return "shape", "a date answer is YYYY-MM-DD"
     if field.type is FieldType.FILE:
         path = Path(values[0])
         if not path.is_absolute():
-            return "a file answer is an absolute path"
+            return "shape", "a file answer is an absolute path"
         if not path.is_file():
-            return f"no file at {path}"
+            return "no_file", f"no file at {path}"
     return None
 
 
@@ -166,39 +183,37 @@ def as_listed(fields: list[Field], answers: dict[str, Answer]) -> dict[str, Answ
     return out
 
 
-def problems(fields: list[Field], answers: dict[str, Answer]) -> list[str]:
+def problems(fields: list[Field], answers: dict[str, Answer]) -> list[Problem]:
     """What refuses answers to the form's fields before typing: missing required answers, more
     than one alternative answered, answers to follow-ups the answers keep hidden, bad values."""
     by_id = {f.id: f for f in fields}
     form = Form(fields, known(fields, answers))
     out = [
-        f"no answer for required {f.id} ({f.label})"
+        Problem(f.id, "missing", f"no answer for required {f.id} ({f.label})")
         for f in fields
         if form.required(f) and f.prefilled is None and not f.unfillable and f.id not in answers
     ]
     for key, members in form.groups.items():
         given = [m.id for m in members if m.id in answers]
         if len(given) > 1:
-            out.append(f"{key}: one of {', '.join(given)}, not both")
+            out.append(Problem(key, "both", f"{key}: one of {', '.join(given)}, not both"))
         elif form.group_required(key) and not given and all(m.prefilled is None for m in members):
             labels = " or ".join(dict.fromkeys(m.label for m in members))
-            out.append(f"no answer for required {key} ({labels})")
+            out.append(Problem(key, "missing", f"no answer for required {key} ({labels})"))
     out += [
-        f"{i}: not asked, it shows when {describe(f.shown_when, by_id)}"
+        Problem(i, "not_asked", 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})"
+        Problem(i, "unfillable", f"{i}: cannot be filled ({f.unfillable})")
         for i in answers
         if (f := by_id.get(i)) and f.unfillable
     ]
     out += [
-        f"{i}: {problem}"
+        Problem(i, broken[0], f"{i}: {broken[1]}")
         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, form))
+        if i in by_id and not by_id[i].unfillable and (broken := _answer_problem(by_id[i], a, form))
     ]
     return out
 

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/core/results.py

@@ -108,6 +108,7 @@ class Result:
     notice: str | None = None  # telemetry's, the first time it is on (ADR 0016)
     report: str | None = None  # how to send a failed run's report, when it was not sent
     warnings: list[str] = field(default_factory=list)  # the knockout answers a fill gave
+    refused: list[str] = field(default_factory=list)  # telemetry's `field_id: rule` per problem
 
 
 @dataclass

{atsfill-0.0.8.dev223 → atsfill-0.0.8.dev224}/src/atsfill/core/telemetry.py

@@ -134,6 +134,7 @@ def event(command: str, result: Result) -> dict:
         "verdict": verdict(result),
         "status": result.status.value,
         "reason": _code(result.reason),
+        "refused": result.refused or None,
         "version": version("atsfill"),
         "posting": None if command == "profile" else posting_hash(_posting(result)),
         "source": source,