Files

172 lines
7.5 KiB
Python

"""A host's word to the app's vocabulary: seniority, employment and remote.
Each field is looked up the same way: the host's table in `hosts`, keyed by
the word lowercased, then a word that already is a value of the vocabulary
(what readers stored before they handed on the host's words, and what a
host with the app's own words sends), then, for remote, the shared word map.
An employment word may also match a host's `MATCH` fragments. A word none
of these knows is unmapped: it maps to '' and `lookup` says so,
so the prep stage can list it.
"""
from __future__ import annotations
import re
from collections.abc import Iterable, Mapping
from typing import Any
from app.models import EMPLOYMENTS, REMOTE, SENIORITIES, remote_of
from app.prep.hosts import TABLES
from app.seniority import from_title
#: `host -> field -> {word: value}`, plus `"match"` (`hosts.load`).
Tables = Mapping[str, Mapping[str, Any]]
VOCABULARIES: dict[str, tuple[str, ...]] = {
"seniority": SENIORITIES, "employment": EMPLOYMENTS, "remote": REMOTE}
#: How hosts without a table of their own write remote, after `_squash`:
#: case, spaces, `-` and `_` gone ("On-site", "on_site", "in office").
REMOTE_WORDS: dict[str, str] = {
"remote": "remote", "fullyremote": "remote", "remotefirst": "remote",
"hybrid": "hybrid",
"onsite": "onsite", "office": "onsite", "inoffice": "onsite", "inperson": "onsite",
"officebased": "onsite", "onpremise": "onsite",
}
def _match(rules: Mapping[str, Any], key: str) -> str | None:
"""The value of the first `MATCH` fragment `key` holds, by its mode."""
parts = set(re.split(r"[_-]", key)) if rules["mode"] == "token" else set()
for fragment, value in rules["rules"]:
if fragment in parts if rules["mode"] == "token" else fragment in key:
return str(value)
return None
#: Remote and hybrid in a line of Danish, Swedish or English that `remote_of`
#: does not read: "Nordhavn og mulighed for hjemmearbejde", "Arbete på distans".
#: Remote first, since "fuldt hjemmearbejde" is remote.
_REMOTE_LINE = re.compile(
r"\bremote\b|fjernarbejde|fuldt hjemmearbejde|distansarbete|på distans", re.IGNORECASE)
_HYBRID_LINE = re.compile(r"\bhybrid|hjemmearbejde", re.IGNORECASE)
#: "Remote" in a title that names a field or a product, not how the role is
#: worked: "Remote Sensing Specialist", "Remote Control Engineer".
_NOT_REMOTE_WORK = re.compile(r"\bremote[\s-]+(?:sensing|control\w*|monitoring)\b",
re.IGNORECASE)
#: Phrases in a title or text that say the role is worked remotely, and the
#: phrases that take one back. Both are read on the lowercased text with its
#: hyphens and runs of spaces squashed to one space. A match marks the role as
#: possibly remote (`remote_in_text`); it decides nothing by itself.
REMOTE_TEXT: tuple[str, ...] = (
"fully remote", "100% remote", "100 % remote", "remote first", "remote work",
"remote working", "work remotely", "working remotely", "remote position", "remote role",
"remote job", "remote team", "remote friendly", "remote possible", "remote option",
"remote ok", "work from home", "working from home", "work from anywhere", "home based",
"home office", "homeoffice", "hjemmearbejde", "fjernarbejde", "distansarbete",
)
REMOTE_TEXT_NOT: tuple[str, ...] = (
"no remote", "not remote", "not a remote", "non remote", "not be remote", "cannot be remote",
"no home office", "kein homeoffice", "not available remotely", "not open to remote",
"remote work is not", "remote working is not", "is not a remote", "remote sensing",
"remote control", "remote monitoring",
)
_REMOTE_TEXT = re.compile("|".join(rf"\b{re.escape(p)}\b" for p in REMOTE_TEXT))
_REMOTE_TEXT_NOT = re.compile("|".join(rf"\b{re.escape(p)}\b" for p in REMOTE_TEXT_NOT))
_SQUASHED = re.compile(r"[\s-]+")
def remote_in_text(title: str, text: str) -> bool:
"""Whether the title or the text says the role is worked remotely: a
phrase of `REMOTE_TEXT` left once those of `REMOTE_TEXT_NOT` are taken
out. Cheap evidence, no model: a role marked so passes a location gate
on remote until extract has read it (ADR Fetch prep and score 1.1), so a
false mark costs a cut slot at most, and a missed one nothing new."""
folded = _SQUASHED.sub(" ", f"{title or ''} {text or ''}".lower())
return bool(_REMOTE_TEXT.search(_REMOTE_TEXT_NOT.sub(" ", folded)))
def _line_word(text: str) -> str:
"""`remote_of`'s reading of a line, else its Danish and Swedish words."""
if found := remote_of(text):
return found
if _REMOTE_LINE.search(text):
return "remote"
return "hybrid" if _HYBRID_LINE.search(text) else ""
def _squash(word: str) -> str:
return "".join(c for c in word.lower() if c not in " -_")
def lookup(field: str, host: str, word: str,
tables: Tables = TABLES) -> str | None:
"""The value `word` maps to for `host`, '' for a known word that names
none, None for a word nothing knows. An empty word is ''."""
key = (word or "").strip().lower()
if not key:
return ""
table = tables.get(host, {})
found = table.get(field, {}).get(key)
if found is None and field == "employment" and "match" in table:
found = _match(table["match"], key)
if found is not None:
return found
if key in VOCABULARIES[field]:
return key
if field == "remote":
return REMOTE_WORDS.get(_squash(key))
return None
def seniority(host: str, word: str, title: str,
tables: Tables = TABLES) -> tuple[str, str]:
"""`(stated, from the title)`: the host's word through its table, and
`seniority.from_title`. `roles.seniority` is the model's level, else the
stated one, else the title's (`Store.write_prep`)."""
return lookup("seniority", host, word, tables) or "", from_title(title)
def employment(host: str, word: str,
tables: Tables = TABLES) -> str:
return lookup("employment", host, word, tables) or ""
def place_text(place: Any) -> str:
"""A place of `raw`'s `places`, a dict with `text` or a string, as its text."""
return str((place.get("text") if isinstance(place, Mapping) else place) or "")
def remote(host: str, value: Any, places: Iterable[Any] = (), line: str = "",
tables: Tables = TABLES, title: str = "") -> str:
"""How the role is worked, one of `REMOTE` or ''.
`value` is the host's own (a bool, or its word; `host_word`'s 'true' and
'false' are bools). True is remote. False says nothing more than the
places do: SmartRecruiters, Ashby, Recruitee and Workable send it for
every role that is not remote, hybrid ones included. A word goes
through the host's table, else the shared map. When the value says
nothing, the place line or the place texts are read for a word
(`remote_of`: "Hybrid, Berlin", and the Danish and Swedish words), then
`title` when given, which the stage gives for a search provider's role
only ("Backend Developer - Remote", but not "Remote Sensing Analyst"),
and last a place the reader marked remote is remote."""
if value is True or value == "true":
return "remote"
said = value not in (None, False, "false")
if said and (found := lookup("remote", host, str(value), tables)):
return found
places = list(places)
if found := _line_word(line or "; ".join(map(place_text, places))):
return found
if title and (found := _line_word(_NOT_REMOTE_WORK.sub(" ", title))):
return found
if any(isinstance(p, Mapping) and p.get("remote") is True for p in places):
return "remote"
return ""