atsfill 0.0.5.dev158__tar.gz → 0.0.5.dev161__tar.gz

{atsfill-0.0.5.dev158 → atsfill-0.0.5.dev161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.5.dev158
+Version: 0.0.5.dev161
 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
@@ -83,6 +83,7 @@ It is built for agents with a shell: every command prints one JSON document and
 [![hiringthing run history](https://shbernal.github.io/atsfill/run-history/hiringthing.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![recruiterflow run history](https://shbernal.github.io/atsfill/run-history/recruiterflow.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![jobaffinity run history](https://shbernal.github.io/atsfill/run-history/jobaffinity.svg)](https://shbernal.github.io/atsfill/run-history/)
+[![welcomekit run history](https://shbernal.github.io/atsfill/run-history/welcomekit.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![join run history](https://shbernal.github.io/atsfill/run-history/join.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![workatastartup run history](https://shbernal.github.io/atsfill/run-history/workatastartup.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![wttj run history](https://shbernal.github.io/atsfill/run-history/wttj.svg)](https://shbernal.github.io/atsfill/run-history/)

{atsfill-0.0.5.dev158 → atsfill-0.0.5.dev161}/README.md

@@ -54,6 +54,7 @@ It is built for agents with a shell: every command prints one JSON document and
 [![hiringthing run history](https://shbernal.github.io/atsfill/run-history/hiringthing.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![recruiterflow run history](https://shbernal.github.io/atsfill/run-history/recruiterflow.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![jobaffinity run history](https://shbernal.github.io/atsfill/run-history/jobaffinity.svg)](https://shbernal.github.io/atsfill/run-history/)
+[![welcomekit run history](https://shbernal.github.io/atsfill/run-history/welcomekit.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![join run history](https://shbernal.github.io/atsfill/run-history/join.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![workatastartup run history](https://shbernal.github.io/atsfill/run-history/workatastartup.svg)](https://shbernal.github.io/atsfill/run-history/)
 [![wttj run history](https://shbernal.github.io/atsfill/run-history/wttj.svg)](https://shbernal.github.io/atsfill/run-history/)

{atsfill-0.0.5.dev158 → atsfill-0.0.5.dev161}/pyproject.toml

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

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.5.dev158"
+version = "0.0.5.dev161"
 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.5.dev158 → atsfill-0.0.5.dev161}/src/atsfill/adapters/__init__.py

@@ -27,6 +27,7 @@ from atsfill.adapters.smartrecruiters import SmartRecruiters
 from atsfill.adapters.successfactors import SuccessFactors
 from atsfill.adapters.teamtailor import Teamtailor
 from atsfill.adapters.ukg import UKG
+from atsfill.adapters.welcomekit import WelcomeKit
 from atsfill.adapters.workable import Workable
 from atsfill.adapters.workatastartup import WorkAtAStartup
 from atsfill.adapters.workday import Workday
@@ -45,6 +46,7 @@ def adapters() -> list[Adapter]:
         WorkAtAStartup(),
         Join(),
         JobAffinity(),
+        WelcomeKit(),
         SmartRecruiters(),
         Oracle(),
         Manatal(),

{atsfill-0.0.5.dev158 → atsfill-0.0.5.dev161}/src/atsfill/adapters/join.py

@@ -3,12 +3,16 @@
 Applying is a wizard of one step per page, ending on a review page whose Confirm & apply is the
 send. Signed in, the wizard takes the name from the account and asks the CV, a cover letter and
 the job's screening questions, which the page's own GraphQL query lists. The fill walks the
-steps to the review page, and the read-back is what the review page lists.
+steps to the review page, and the read-back is what the review page lists. What the wizard takes
+from the account (name, phone, country, city, links) is the account profile's, a form of one
+profile step that `profile` saves (ADR 0017).
 """
 
 import json
 import re
 import time
+from collections.abc import Callable
+from dataclasses import replace
 from typing import Any
 from urllib.parse import urlsplit
 
@@ -17,10 +21,10 @@ from atsfill.core.adapter import (
     Blocked,
     Gap,
     NotTaken,
+    ProfileIncomplete,
     Refused,
     SignUpDetails,
     Unsupported,
-    known_gap,
 )
 from atsfill.core.browser import Locator, Page, Request, Response, Timeout
 from atsfill.core.results import Answer, Field, FieldType, SideEffect
@@ -31,7 +35,13 @@ ME = f"https://{HOST}/api/me"
 GRAPHQL = f"https://{HOST}/candidate-api/graphql"
 LOGIN = f"https://{HOST}/auth/login/candidate?redirectUrl=%2Ftalent%2Fhome"
 UNVERIFIED = "/auth/candidates/unverified-email"
+PROFILE = f"https://{HOST}/talent/me?edit=profile"
+GENERAL = "general"  # the account profile's one profile step
 STEP_TIMEOUT_MS = 20_000
+PROFILE_TIMEOUT_MS = 20_000
+SAVE_TIMEOUT_MS = 20_000
+MENU_TIMEOUT_MS = 5_000
+SUGGEST_TIMEOUT_MS = 10_000  # the city's suggestions come from a request per search
 UPLOAD_TIMEOUT_MS = 30_000
 ACCOUNT_TIMEOUT_MS = 20_000
 SUBMIT_TIMEOUT_MS = 60_000
@@ -57,8 +67,27 @@ CLASS_STEPS = {
     "availability": "AVAILABILITY",
 }
 PROFILE_STEPS = ("personalInformation", "professionalLinks")  # the account profile's
+# What a wizard's profile step can ask that the account profile lacks, by input id.
+LACKS = {
+    "candidate.firstName": "a first name",
+    "candidate.lastName": "a last name",
+    "candidate.phoneNumber": "a phone",
+}
 PDF = [".pdf", "application/pdf"]
 
+# The profile form's controls, by its field ids.
+TEXTS = {
+    "first_name": "candidate.firstName",
+    "last_name": "candidate.lastName",
+    "linkedin": "professionalLinks.LINKEDIN",
+}
+COUNTRY = '[id="candidate.countryId"]'
+CITY = "[data-testid=CityName]"
+PHONE = '[id="candidate.phoneNumber"]'
+DIAL = "[data-phone-input] button"  # the phone's country code, a popover of countries
+POPOVER = "[data-scope=popover][data-part=content]"
+DIAL_CODE = re.compile(r"\(\+(\d+)\)\s*$")  # an option of the popover: `France (+33)`
+
 # The page's own GraphQL request, from the page.
 _FETCH = """async ([url, body]) => (await fetch(url, {method: "POST", body: JSON.stringify(body),
   headers: {"content-type": "application/json"}})).json()"""
@@ -70,14 +99,26 @@ _REVIEW = """() => [...document.querySelectorAll("a > div")].map(div => {
     ? [label.textContent.trim(), value.textContent.trim()] : null;
 }).filter(Boolean)"""
 
+# A select's value: the paragraph it shows, not an option of its open menu.
+_SHOWN = """root => {
+  const p = [...root.querySelectorAll("p")].find(p => !p.closest("[role=option]"));
+  return p ? p.textContent.trim() : "";
+}"""
+
+# The ids of the inputs that are empty, of those given.
+_EMPTY = (
+    """ids => ids.filter(id => { const e = document.getElementById(id); return e && !e.value; })"""
+)
+
 
 class Join:
     name = "join"
     per_employer = False
     asks = {"name"}  # the account's first and last name
-    known_gaps = {"profile_incomplete": Gap.FLOW}
+    known_gaps: dict[str, Gap] = {}
     side_effects = [
         SideEffect("sign_up", "hiring_system", "login --create creates the candidate account"),
+        SideEffect("profile", "hiring_system", "profile --answers saves the account profile"),
         SideEffect("upload", "hiring_system", "a file is stored as soon as it is chosen"),
         SideEffect("submit", "employer", "the application reaches the employer"),
     ]
@@ -196,9 +237,11 @@ class Join:
             elif step in PROFILE_STEPS:
                 try:  # shown when the job requires what the account profile lacks
                     _next(page, step)
-                except NotTaken, RuntimeError:
-                    detail = f"the {step} step asks what the account profile lacks"
-                    raise Unsupported(known_gap(self, "profile_incomplete", detail)) from None
+                except NotTaken, RuntimeError:  # Continue disabled, or refused on click
+                    lacks = [LACKS[i] for i in page.evaluate(_EMPTY, list(LACKS))]
+                    raise ProfileIncomplete(
+                        f"the job asks for {' and '.join(lacks) or f'what {step} asks'}"
+                    ) from None
                 continue
             else:
                 raise Unsupported(f"unhandled_rendering: a wizard step {step!r}")
@@ -239,6 +282,83 @@ class Join:
             return f"POST {parts.path}?{parts.query} {response.status}"
         raise RuntimeError(f"POST {response.url} answered {response.status}: {body.get('errors')}")
 
+    def profile_url(self, scope: str | None) -> str:
+        return PROFILE
+
+    def profile_steps(self, page: Page) -> list[str]:
+        return [GENERAL]
+
+    def open_step(self, page: Page, step: str) -> bool:
+        if step != GENERAL:
+            raise Unsupported(f"unhandled_rendering: a profile step {step!r}")
+        if page.url != PROFILE:
+            page.goto(PROFILE)
+        page.locator(f'[id="{TEXTS["first_name"]}"]').wait_for(timeout=PROFILE_TIMEOUT_MS)
+        return True
+
+    def profile_read(self, page: Page) -> list[Field]:
+        """The general information form: the name, the phone, the country and city of residence
+        and the LinkedIn URL. The photo, the bio, the work authorizations and the other links are
+        left as they are, as are the profile's other sections (experience, education, …)."""
+        saved = self.profile_read_back(page)
+        limit = {
+            k: int(page.locator(f'[id="{i}"]').get_attribute("maxlength") or 0) or None
+            for k, i in TEXTS.items()
+        }
+        fields = [
+            Field("first_name", "First name", FieldType.TEXT, True, max_length=limit["first_name"]),
+            Field("last_name", "Last name", FieldType.TEXT, True, max_length=limit["last_name"]),
+            Field("phone", "Phone number, with its country code", FieldType.PHONE, False),
+            Field("country", "Country of residence", FieldType.CHOICE, True, _menu(page, COUNTRY)),
+            Field("city", "City, in the country of residence", FieldType.TYPEAHEAD, False),
+            Field("linkedin", "LinkedIn", FieldType.URL, False),
+        ]  # fmt: skip
+        return [replace(f, prefilled=saved.get(f.id)) for f in fields]
+
+    def profile_fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        """In the form's order: the city is searched in the country of residence."""
+        for field_id, input_id in TEXTS.items():
+            if isinstance(answer := answers.get(field_id), str):
+                page.locator(f'[id="{input_id}"]').fill(answer)
+        if isinstance(answer := answers.get("phone"), str):
+            _phone(page, answer)
+        if isinstance(answer := answers.get("country"), str):
+            _pick(page, COUNTRY, answer, lambda text: text == answer, MENU_TIMEOUT_MS)
+        if isinstance(answer := answers.get("city"), str):
+            _pick(page, CITY, answer, lambda text: True, SUGGEST_TIMEOUT_MS)
+
+    def profile_read_back(self, page: Page) -> dict[str, Answer]:
+        values = {k: page.locator(f'[id="{i}"]').input_value() for k, i in TEXTS.items()}
+        phone = page.locator(PHONE)
+        if phone.input_value():  # `data-value` holds the country code and the number
+            values["phone"] = phone.get_attribute("data-value") or ""
+        values["country"] = _shown(page, COUNTRY)
+        values["city"] = _shown(page, CITY)
+        return {k: v for k, v in values.items() if v}
+
+    def save(self, page: Page) -> None:
+        """Save changes posts `UpdateTalentPersonalInformation`; the button stays disabled while
+        a required field is empty or nothing changed."""
+        button = page.locator("form button[type=submit]").last
+        try:  # it is enabled a moment after the last change
+            page.wait_for_function(
+                "e => !e.disabled", arg=button.element_handle(), timeout=BUTTON_TIMEOUT_MS
+            )
+        except Timeout:
+            raise Refused(
+                f"step_refused: {GENERAL}: the form keeps its Save button disabled"
+            ) from None
+        with page.expect_response(
+            lambda r: "operationName=UpdateTalentPersonalInformation" in r.url,
+            timeout=SAVE_TIMEOUT_MS,
+        ) as sent:
+            button.click()
+        response = sent.value
+        if not response.ok:
+            raise RuntimeError(f"UpdateTalentPersonalInformation answered {response.status}")
+        if errors := response.json().get("errors"):
+            raise Refused(f"step_refused: {GENERAL}: {errors[0].get('message')}")
+
     def _file(self, page: Page, field_id: str, answer: Answer | None) -> None:
         if not isinstance(answer, str):
             return
@@ -348,6 +468,62 @@ def _date(page: Page, answer: str) -> None:
     (trigger if trigger.count() else day.first).click()
 
 
+def _select(page: Page, container: str) -> tuple[Locator, Locator]:
+    """A select of the profile form: its combobox, and the options its menu shows, whose ids
+    carry the combobox's."""
+    box = page.locator(container).locator("input[role=combobox]")
+    suffix = (box.get_attribute("id") or "").removeprefix("select-input-")
+    return box, page.locator(f'[id^="react-select-{suffix}-option-"]')
+
+
+def _menu(page: Page, container: str) -> list[str]:
+    box, options = _select(page, container)
+    box.click()
+    options.first.wait_for(timeout=MENU_TIMEOUT_MS)
+    texts = [t.strip() for t in options.all_inner_texts()]
+    box.press("Escape")
+    return texts
+
+
+def _pick(page: Page, container: str, answer: str, take: Callable[[str], bool], ms: int) -> None:
+    """Searches the select for the answer and picks the first option `take` accepts."""
+    box, options = _select(page, container)
+    box.click()
+    box.fill(answer)
+    try:
+        options.first.wait_for(timeout=ms)
+    except Timeout:
+        raise NotTaken(f"no option for {answer!r}") from None
+    texts = [t.strip() for t in options.all_inner_texts()]
+    picked = next((i for i, text in enumerate(texts) if take(text)), None)
+    if picked is None:
+        raise NotTaken(f"no option {answer!r} in {texts}")
+    options.nth(picked).click()
+
+
+def _shown(page: Page, container: str) -> str:
+    """A select's value as it shows, empty under its placeholder."""
+    return page.locator(container).first.evaluate(_SHOWN)
+
+
+def _phone(page: Page, answer: str) -> None:
+    """Picks the country whose code starts the answer, the longest of them, then types the rest:
+    the number's input takes digits only."""
+    digits = re.sub(r"\D", "", answer)
+    if not answer.strip().startswith("+"):
+        raise NotTaken(f"the phone {answer!r} has no country code, `+<code> <number>`")
+    page.locator(DIAL).click()
+    options = page.locator(POPOVER).locator("[role=option]")
+    options.first.wait_for(timeout=MENU_TIMEOUT_MS)
+    codes = [m[1] if (m := DIAL_CODE.search(t)) else "" for t in options.all_inner_texts()]
+    starting = [i for i, code in enumerate(codes) if code and digits.startswith(code)]
+    if not starting:
+        raise NotTaken(f"no country code starts the phone {answer!r}")
+    picked = max(starting, key=lambda i: len(codes[i]))
+    options.nth(picked).click()
+    page.locator(PHONE).fill(digits[len(codes[picked]) :])
+
+
 def _email_step(page: Page, email: str) -> bool:
     """The account page's first step: the email. Whether an account has it, from what the page
     asks next: a password alone for one, a name and a password for none."""

atsfill-0.0.5.dev161/src/atsfill/adapters/welcomekit.py

@@ -0,0 +1,366 @@
+"""WelcomeKit, Welcome to the Jungle's ATS, as docs/adapters/welcomekit.md observes.
+
+Two forms, by host. The older one (`welcomekit.co/candidates/new?o=<org>&j=<job>`) is a Rails
+form rendered on the server: `request_read` fetches it over HTTP, `browser_read` takes the page's
+HTML, one parser lists the fields. The newer one (`ats.welcometothejungle.com/board/<org>/job/
+<id>/apply`) is a React app over a JSON API: fixed personal fields, then the job's questions as
+the API declares them; both reads list the fields from that JSON.
+"""
+
+import json
+import re
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from urllib.parse import parse_qs, urlsplit
+
+from atsfill.core import html
+from atsfill.core.adapter import Blocked, Gap, Unsupported
+from atsfill.core.browser import HTTP_TIMEOUT_S, Page, Timeout
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+OLD_ORIGIN = "https://www.welcomekit.co"
+OLD_HOST = re.compile(r"^(?:www\.)?welcomekit\.co$")
+OLD_PATH = "/candidates/new"
+OLD = "form#new_candidate"
+NEW_ORIGIN = "https://ats.welcometothejungle.com"
+NEW_HOST = "ats.welcometothejungle.com"
+NEW_PATH = re.compile(r"^/board/([\w-]+)/job/([0-9a-f-]{36})(?:/apply)?/?$")
+API = "https://api.ats.welcometothejungle.com/api/v1/board/organizations/{org}/jobs/{job}"
+NEW_SUBMIT = "[data-testid=submit-application-button]"
+CAPTCHA = "iframe[title=reCAPTCHA]"
+CHALLENGE = "iframe[src*='recaptcha/api2/bframe']"
+FORM_TIMEOUT_MS = 30_000
+UPLOAD_TIMEOUT_MS = 30_000
+CAPTCHA_TIMEOUT_MS = 20_000
+SUBMIT_TIMEOUT_MS = 90_000
+YES_NO = ["Yes", "No"]
+PHOTO = ["image/png", "image/jpeg", "image/gif"]  # the photo's input declares no type
+# The newer form's personal fields, always drawn: (name, label, type, required)
+PERSONAL = [
+    ("firstname", "First name", FieldType.TEXT, True),
+    ("lastname", "Last name", FieldType.TEXT, True),
+    ("email", "Email address", FieldType.TEXT, True),
+    ("linkedin_url", "LinkedIn profile URL", FieldType.URL, False),
+    ("phone_number", "Phone number", FieldType.PHONE, False),
+    ("personal_website_url", "Personal website URL", FieldType.URL, False),
+]
+QUESTION_KINDS = {"text": FieldType.TEXT, "boolean": FieldType.CHOICE, "document": FieldType.FILE}
+
+# What each control holds, by name: a value, a select's option text, a box as Yes/No, a file's
+# name; a newer form's boolean question, by its place among them, as its selected button.
+_READ_BACK = """(form, controls) => {
+  const out = {};
+  const booleans = [...form.querySelectorAll("[data-testid=board-boolean-field-true]")]
+    .map(b => b.parentElement);
+  for (const c of controls) {
+    if (c.kind === "boolean") {
+      const selected = booleans[c.place]?.querySelector("[data-selected=true]");
+      out[c.id] = selected?.textContent.trim() ?? "";
+      continue;
+    }
+    const el = form.querySelector(`[name="${c.name}"]:not([type=hidden])`);
+    if (!el) continue;
+    if (c.kind === "select") out[c.id] = el.selectedOptions[0]?.textContent.trim() ?? "";
+    else if (c.kind === "checkbox") out[c.id] = el.checked ? "Yes" : "No";
+    else if (c.kind === "file") out[c.id] = el.files[0]?.name ?? "";
+    else if (c.kind === "upload") {
+      const done = el.closest("[data-testid^=file-input-]")?.querySelector("svg.name-check");
+      out[c.id] = done?.parentElement.textContent.trim().replace(/ \\([^()]*\\)$/, "") ?? "";
+    }
+    else out[c.id] = el.value ?? "";
+  }
+  return out;
+}"""
+
+
+@dataclass
+class _Control:
+    field: Field
+    kind: str  # text | select | checkbox | file | boolean | upload
+    name: str  # the control's `name`
+    place: int = 0  # a boolean question's place among the form's boolean questions
+
+
+class WelcomeKit:
+    name = "welcomekit"
+    known_gaps: dict[str, Gap] = {}
+    side_effects = [
+        SideEffect("upload", "hiring_system", "the newer form uploads a file once it is attached"),
+        SideEffect("submit", "employer", "the application reaches the employer"),
+    ]
+
+    def __init__(self) -> None:
+        self._controls: list[_Control] = []
+        self._new = False
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        return _old(url) is not None or _new(url) is not None
+
+    def posting(self, url: str) -> str:
+        if old := _old(url):
+            return f"{OLD_ORIGIN}{OLD_PATH}?o={old[0]}&j={old[1]}"
+        if new := _new(url):
+            return f"{NEW_ORIGIN}/board/{new[0]}/job/{new[1]}/apply"
+        return url
+
+    def request_read(self, url: str) -> list[Field] | None:
+        try:
+            if _old(url):
+                controls = _old_controls(_get(self.posting(url)))
+            elif new := _new(url):
+                controls = _new_controls(json.loads(_get(API.format(org=new[0], job=new[1]))))
+            else:
+                return None
+        except urllib.error.HTTPError, OSError, ValueError:
+            return None
+        return [c.field for c in controls] if controls else None
+
+    def browser_read(self, page: Page) -> list[Field]:
+        if new := _new(page.url):
+            self._new = True
+            if not urlsplit(page.url).path.rstrip("/").endswith("/apply"):
+                page.goto(self.posting(page.url))
+            api = API.format(org=new[0], job=new[1])
+            data = page.evaluate(_FETCH, api)
+            if data is None or not (controls := _new_controls(data)):
+                raise Unsupported("posting_gone: the job is not published")
+            try:
+                page.locator(NEW_SUBMIT).wait_for(timeout=FORM_TIMEOUT_MS)
+            except Timeout:
+                raise Unsupported("posting_gone: no application form on the page") from None
+            for c in controls:  # each declared question is drawn
+                if c.kind == "boolean":
+                    page.locator("[data-testid=board-boolean-field-true]").nth(c.place).wait_for(
+                        state="attached", timeout=FORM_TIMEOUT_MS
+                    )
+                elif c.kind in ("text", "upload") and c.name.startswith("custom_questions"):
+                    page.locator(f"[name='{c.name}']").wait_for(
+                        state="attached", timeout=FORM_TIMEOUT_MS
+                    )
+        else:
+            try:
+                page.locator(OLD).wait_for(state="attached", timeout=FORM_TIMEOUT_MS)
+            except Timeout:
+                raise Unsupported("posting_gone: no application form on the page") from None
+            controls = _old_controls(page.content())
+        self._controls = controls
+        return [c.field for c in controls]
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        form = page.locator("form").first if self._new else page.locator(OLD)
+        for c in self._controls:
+            if c.field.id not in answers or c.field.unfillable:
+                continue
+            value = answers[c.field.id]
+            value = value if isinstance(value, str) else value[0]
+            control = form.locator(f"[name='{c.name}']:not([type=hidden])")
+            match c.kind:
+                case "select":
+                    control.select_option(label=value)
+                case "checkbox":  # drawn over by its iCheck box: its label toggles it
+                    if control.is_checked() != (value == "Yes"):
+                        form.locator(f"label[for='{control.get_attribute('id')}']").click()
+                case "file":
+                    control.set_input_files(value)
+                case "upload":  # the file goes to storage at once; a ticked badge then names it
+                    control.set_input_files(value)
+                    name = value.rsplit("/", 1)[-1]
+                    input_ = page.locator(f"input[name='{c.name}']")
+                    widget = form.locator("[data-testid^=file-input-]").filter(has=input_)
+                    badge = widget.locator("*:has(> svg.name-check)", has_text=name)
+                    badge.first.wait_for(timeout=UPLOAD_TIMEOUT_MS)
+                case "boolean":
+                    testid = "true" if value == "Yes" else "false"
+                    buttons = form.locator(f"[data-testid=board-boolean-field-{testid}]")
+                    button = buttons.nth(c.place)
+                    if button.get_attribute("data-selected") != "true":
+                        button.click()
+                case _:
+                    control.fill(value)
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        form = page.locator("form").first if self._new else page.locator(OLD)
+        controls = [
+            {"id": c.field.id, "name": c.name, "kind": c.kind, "place": c.place}
+            for c in self._controls
+            if not c.field.unfillable
+        ]
+        values = form.evaluate(_READ_BACK, controls)
+        return {k: v for k, v in values.items() if v not in (None, "")}
+
+    def submit(self, page: Page) -> str:
+        """The older form: ticks the reCAPTCHA box, `Blocked` on an image challenge, posts the
+        form and lands on the page after it, the evidence. The newer form: clicks Submit
+        application; the evidence is the answer to the apply POST."""
+        if self._new:
+            return _submit_new(page)
+        captcha = page.locator(CAPTCHA)
+        if captcha.count():
+            captcha.content_frame.locator("#recaptcha-anchor").click()
+            token = page.locator("#g-recaptcha-response")
+            try:
+                page.wait_for_function(
+                    "el => el.value !== ''", arg=token.element_handle(), timeout=CAPTCHA_TIMEOUT_MS
+                )
+            except Timeout:
+                if page.locator(CHALLENGE).is_visible():
+                    raise Blocked("captcha: reCAPTCHA image challenge") from None
+                raise
+        with page.expect_navigation(timeout=SUBMIT_TIMEOUT_MS):
+            page.locator(f"{OLD} [type=submit]").click()
+        if page.locator(OLD).count():
+            raise RuntimeError(f"the form was not taken: {_errors(page)}")
+        return page.url
+
+
+# The newer form's job, fetched from inside the page so it is the browser that asks.
+_FETCH = "url => fetch(url).then(r => r.ok ? r.json() : null)"
+
+
+def _old(url: str) -> tuple[str, str] | None:
+    """The organization and job references, from `welcomekit.co/candidates/new?o=..&j=..`."""
+    parts = urlsplit(url)
+    query = parse_qs(parts.query)
+    o, j = query.get("o", [""])[0], query.get("j", [""])[0]
+    ok = OLD_HOST.match(parts.hostname or "") and parts.path.rstrip("/") == OLD_PATH
+    return (o, j) if ok and o and j else None
+
+
+def _new(url: str) -> tuple[str, str] | None:
+    """The organization slug and the job id, from `ats.welcometothejungle.com/board/..`."""
+    parts = urlsplit(url)
+    match = NEW_PATH.match(parts.path)
+    return (match[1], match[2]) if parts.hostname == NEW_HOST and match else None
+
+
+def _get(url: str) -> str:
+    request = urllib.request.Request(url, headers={"User-Agent": "atsfill"})
+    with urllib.request.urlopen(request, timeout=HTTP_TIMEOUT_S) as response:
+        return response.read().decode()
+
+
+def _old_controls(source: str) -> list[_Control]:
+    """The older form's controls, in the page's order; an unknown job's page has no form."""
+    page = html.parse(source)
+    form = page.find(lambda n: n.tag == "form" and n.attrs.get("id") == "new_candidate")
+    if form is None:
+        return []
+    labels = {n.attrs["for"]: n for n in form.walk() if n.tag == "label" and "for" in n.attrs}
+    out: list[_Control] = []
+    for node in form.walk():
+        name = node.attrs.get("name", "")
+        kind = node.attrs.get("type", "text") if node.tag == "input" else node.tag
+        if node.tag not in ("input", "select", "textarea") or not name.startswith("candidate["):
+            continue
+        if kind == "hidden" or node.closest(lambda n: "hidden" in n.classes()):
+            continue
+        field_id = _id(name)
+        own = labels.get(node.attrs.get("id", ""))
+        label = _text(own) if own is not None else _group_label(node, field_id)
+        required = "required" in node.attrs
+        match kind:
+            case "text" | "email" | "textarea":
+                field, kept = Field(field_id, label, FieldType.TEXT, required), "text"
+            case "tel":
+                field, kept = Field(field_id, label, FieldType.PHONE, required), "text"
+            case "select":
+                options = [
+                    (o, " ".join(o.text().split()))
+                    for o in node.walk()
+                    if o.tag == "option" and o.attrs.get("value")
+                ]
+                default = next((t for o, t in options if "selected" in o.attrs), None)
+                texts = [t for _, t in options]
+                field = Field(field_id, label, FieldType.CHOICE, required, texts, default=default)
+                kept = "select"
+            case "file":
+                accept = node.attrs.get("accept")
+                types = accept.split(",") if accept else PHOTO if field_id == "image" else None
+                field, kept = Field(field_id, label, FieldType.FILE, required, accept=types), "file"
+            case "checkbox":
+                field = Field(field_id, label, FieldType.CHOICE, required, YES_NO)
+                kept = "checkbox"
+            case _:
+                reason = f"unhandled_rendering: {field_id} is a {kind}"
+                field = Field(field_id, label, FieldType.TEXT, required, unfillable=reason)
+                kept = "text"
+        out.append(_Control(field, kept, name))
+    return out
+
+
+def _id(name: str) -> str:
+    """`candidate[profile_attributes][firstname]` is `firstname`, `candidate[answers[0][answer]]`
+    `answers.0`."""
+    parts = re.findall(r"\w+", name)[1:]
+    parts = [p for p in parts if p != "profile_attributes"]
+    return ".".join(parts[:-1] if parts[0] == "answers" else parts)
+
+
+def _group_label(node: html.Node, field_id: str) -> str:
+    """An address part's label: its group's, with the part's placeholder; the country list,
+    which has none and lists its countries in English, `Country`."""
+    group = node.closest(lambda n: "address" in n.classes() and "form-group" in n.classes())
+    label = group.find(lambda n: n.tag == "label") if group else None
+    placeholder = node.attrs.get("placeholder", "Country" if node.tag == "select" else "")
+    if label is None:
+        return placeholder or field_id
+    return f"{_text(label)}: {placeholder}" if placeholder else _text(label)
+
+
+def _text(label: html.Node) -> str:
+    return " ".join(label.text().split()).removesuffix("*").strip()
+
+
+def _new_controls(data: dict) -> list[_Control]:
+    """The newer form's controls from its job's JSON: the personal fields, the résumé, then the
+    questions by their order; none for a job that is not published."""
+    job = data.get("job") or {}
+    if job.get("status") != "published":
+        return []
+    out = [_Control(Field(n, t, k, r), "text", n) for n, t, k, r in PERSONAL]
+    cv = Field("cv", "Resume", FieldType.FILE, True, accept=[".pdf"])
+    out.append(_Control(cv, "upload", "cv"))
+    booleans = 0
+    questions = sorted(job.get("questions") or [], key=lambda q: q.get("order") or 0)
+    for n, q in enumerate(questions):
+        name = f"custom_questions.{n}.answer"
+        field_id, label, required = f"custom_questions.{n}", q["label"].strip(), q["required"]
+        match q["type"]:
+            case "boolean":
+                field = Field(field_id, label, FieldType.CHOICE, required, YES_NO)
+                out.append(_Control(field, "boolean", name, booleans))
+                booleans += 1
+            case "document":
+                field = Field(field_id, label, FieldType.FILE, required, accept=[".pdf"])
+                out.append(_Control(field, "upload", name))
+            case "text":
+                out.append(_Control(Field(field_id, label, FieldType.TEXT, required), "text", name))
+            case other:
+                reason = f"unhandled_rendering: {field_id} is a {other} question"
+                field = Field(field_id, label, FieldType.TEXT, required, unfillable=reason)
+                out.append(_Control(field, "text", name))
+    return out
+
+
+def _submit_new(page: Page) -> str:
+    new = _new(page.url)
+    assert new is not None
+    path = urlsplit(API.format(org=new[0], job=new[1])).path + "/apply"
+    try:
+        with page.expect_response(
+            lambda r: r.request.method == "POST" and urlsplit(r.url).path == path,
+            timeout=SUBMIT_TIMEOUT_MS,
+        ) as applied:
+            page.locator(NEW_SUBMIT).click()
+    except Timeout:
+        raise RuntimeError(f"nothing posted: {_errors(page)}") from None
+    response = applied.value
+    if not response.ok:
+        raise RuntimeError(f"apply answered {response.status}: {response.text()[:200]}")
+    return f"{response.url} {response.status}"
+
+
+def _errors(page: Page) -> str:
+    shown = page.locator(".help-block:visible, .error:visible, [role=alert]:visible")
+    return " ".join(" ".join(shown.all_inner_texts()).split())[:200] or "no error shown"

{atsfill-0.0.5.dev158 → atsfill-0.0.5.dev161}/src/atsfill/registry.toml

@@ -420,3 +420,10 @@ account = "none"
 hosting = ["hosted"]
 adapter = "jobaffinity"
 scope = { is = "supported", date = 2026-10-28, commit = "02939fd" }
+
+[welcomekit]
+kind = "ats"
+account = "none"
+hosting = ["hosted"]
+adapter = "welcomekit"
+scope = { is = "supported", date = 2026-10-29, commit = "238798d" }