The location gate rejects on evidence only: a place gate is empty for a role with no place the gazetteer resolved, an any group whose country and place members are all empty passes whatever remote says, and a role place that holds one of a country or place gate's places (Øresund, Sweden, Europe) meets it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Fable 5.1 committed 2026-10-05 09:25:43 +02:00
1 parent 1127d06f03
commit 3388b97cf4
4 files changed
+150 -22

No files matched your search

+16 -6
View File
@@ -9,16 +9,19 @@ good for a given search. Each agent first applies its fetch gate:
lifts
any gates one group, the place part: a role that matches none of
them, and has the column filled for at least one, is
gated ("none of country DK / remote remote"); skipped for
a company set to All locations
gated ("none of country DK / remote remote"), unless its
location is unknown; skipped for a company set to All
locations
exclude gates a role that matches one of the values keeps its row, with
score 0 and the value ("title account executive"); those
on `title` are skipped for a company set to All roles
A gate rejects on evidence, never on absence: a role whose column is empty
is not gated by it. `extract` is what fills an empty column, and it reads
only the roles in the cut, so gating on an empty column would keep those
roles out of extract's reach for good. A hidden company (`affinity = -1`)
is not gated by it, and a place the gazetteer could not resolve, or one
that holds the agent's places (Øresund for Copenhagen), is no evidence.
`extract` is what fills an empty column, and it reads only the roles in
the cut, so gating on an empty column would keep those roles out of
extract's reach for good. A hidden company (`affinity = -1`)
is not scored at all; a favourite passes the gate like any other company.
The final score, the feed's order, is the weighted sum of four terms over
@@ -181,6 +184,10 @@ def failed_gates(candidate: Candidate, gates: Sequence[Gate]) -> list[str]:
it fails, every exclude gate it matches, and the `any` group when it
matches none of them. A gate with an empty column (state -1) neither
passes nor fails, so the group fails only when some member had evidence.
A role whose location is unknown, every `country` and `place` member
empty, passes the group whatever its remote says: a hybrid role with no
place may still be in one of the agent's towns, and extract reads it
only in the cut. A group of remote alone still fails a hybrid role.
A company set to All locations skips the `any` group, the place part,
and one set to All roles the exclude gates on `title`, the titles to
leave out; the require gates, the region, apply to every company."""
@@ -190,7 +197,10 @@ def failed_gates(candidate: Candidate, gates: Sequence[Gate]) -> list[str]:
if g.mode == "exclude" and state > 0
and not (candidate.all_roles and g.field == "title")]
group = [(g, state) for g, state in states if g.mode == "any"]
if not candidate.all_countries and group and not any(state == 1 for _, state in group) \
located = [state for g, state in group if g.field in ("country", "place")]
unknown = bool(located) and all(state == -1 for state in located)
if not candidate.all_countries and group and not unknown \
and not any(state == 1 for _, state in group) \
and any(state == 0 for _, state in group):
reasons.append("none of " + ", ".join(_wanted(g) for g, _ in group))
return reasons
+31 -12
View File
@@ -289,14 +289,22 @@ def _gate_sql(gate: Gate, gaz: places.Gazetteer) -> tuple[str, str, list[Any]]:
`params` belong to `match`; `empty` takes none.
`country` and `place` match over the gazetteer, as the feed's Place
filter does (`_places_sql`): a country gate is met by a role whose
`country` is one of its codes or that has a place in one of them, so
`DK` is met by `Copenhagen; London`. Its column is empty only when the
role has neither. A `require` gate on country reads a remote role whose
filter does (`_places_sql`), and also on a role place that holds one of
the gate's places (`wider`): a country gate is met by a role whose
`country` is one of its codes or that has a place in or around one of
them, so `DK` is met by `Copenhagen; London`, and by Øresund or Europe
alone, which are no evidence the role is outside Denmark; a town in
Germany is. Its column is empty only when the role has neither a country
nor a resolved place. A `require` gate on country reads a remote role whose
area is stated through the area alone, as the remote chips do
(`Gazetteer.overlap`): "Home Based - Worldwide" and "Germany (Remote)"
meet Europe, "Remote US" does not, and neither is empty. A place gate's
value is a place token, bare text a `place:`.
value is a place token, bare text a `place:`. Its column is empty when
the role has no place the gazetteer resolved, as "Storkøbenhavn" or
"Headquarters" are not: that is no evidence the role is elsewhere. Such
a role can still match, by its country or by whole words of its line
for a town the gazetteer does not know, so a place gate's `match` is
tested before its `empty` (`Store.score_candidates`).
`remote_from` takes place tokens without their `remote:` (`country:DK`,
`anywhere`) and matches as the remote chips do. It is empty for a role
@@ -314,7 +322,8 @@ def _gate_sql(gate: Gate, gaz: places.Gazetteer) -> tuple[str, str, list[Any]]:
return f"(r.remote = '' OR (r.remote = 'remote' AND NOT {_HAS_AREA}))", match, params
if gate.field == "country":
tokens = [f"country:{v}" for v in values]
match, params = _places_sql(tokens, gaz, table="r", codes=[v.upper() for v in values])
match, params = _places_sql(tokens, gaz, table="r", codes=[v.upper() for v in values],
wider=True)
empty = f"(r.country = '' AND {_unplaced(gaz)})"
if gate.mode != "require":
return empty, match, params
@@ -323,8 +332,8 @@ def _gate_sql(gate: Gate, gaz: places.Gazetteer) -> tuple[str, str, list[Any]]:
return (f"({empty} AND NOT {_HAS_AREA})",
f"(CASE WHEN {_HAS_AREA} THEN {area} ELSE {match} END)", [*more, *params])
if gate.field == "place":
match, params = _places_sql(values, gaz, table="r")
return "r.place = ''", match, params
match, params = _places_sql(values, gaz, table="r", wider=True)
return _unplaced(gaz), match, params
if gate.field == "title":
# Whole words of the folded title: " account executive " inside
# " enterprise account executive uk ". A fold drops `%` and `_`, so a
@@ -344,13 +353,19 @@ def _gate_sql(gate: Gate, gaz: places.Gazetteer) -> tuple[str, str, list[Any]]:
def _places_sql(tokens: Sequence[str], gaz: places.Gazetteer, *, table: str = "roles",
codes: Sequence[str] = (), scope: Sequence[Gate] = ()) -> tuple[str, list[Any]]:
codes: Sequence[str] = (), scope: Sequence[Gate] = (),
wider: bool = False) -> tuple[str, list[Any]]:
"""Any of the place tokens over `table`, as a join over the gazetteer: a
role with a place under one of the places the tokens name (`country:DK`
every place in Denmark, `region:skane` every town in Skåne, `place:malmo`
Malmö by any spelling), or whose `country` is one of their countries (a
role whose board gave a country and no place). `codes` are more values of
`country` to accept. A `place:` token the gazetteer does not know is
`country` to accept. `wider` also takes a role place that holds one of
them (`Gazetteer.overlap`): Øresund, Europe or Anywhere meet
`country:DK`, as the fetch gate reads them (`_gate_sql`); the feed's
Place filter leaves it off. The `country` column is not widened, as
Sweden would then meet Malmö for a role in Stockholm. A `place:` token
the gazetteer does not know is
matched on whole words of the role's folded line (`places.match_sql`),
so a town nobody has entered yet is still found.
@@ -381,7 +396,7 @@ def _places_sql(tokens: Sequence[str], gaz: places.Gazetteer, *, table: str = "r
params += values
continue
under = gaz.under(named)
ids |= under
ids |= gaz.overlap(named) if wider else under
found |= gaz.codes(under)
if ids:
clauses.insert(0, f"{table}.uid IN (SELECT uid FROM role_places "
@@ -2317,7 +2332,11 @@ class Store:
empty, match, values = _gate_sql(part, gaz)
whens.append(f"WHEN {match} THEN {k}")
params += values
columns.append(f"CASE WHEN {empty} THEN -1 {' '.join(whens)} ELSE 0 END AS g{n}")
# A place gate's match goes first: an unresolved place can still
# meet one of its values (`_gate_sql`).
case = (f"{' '.join(whens)} WHEN {empty} THEN -1" if gate.field == "place"
else f"WHEN {empty} THEN -1 {' '.join(whens)}")
columns.append(f"CASE {case} ELSE 0 END AS g{n}")
select = ", ".join(["r.uid", "r.posted_at",
"COALESCE(ac.affinity, 0) AS affinity",
"COALESCE(c.all_countries, 0) AS all_countries",
+2 -1
View File
@@ -328,8 +328,9 @@ def test_a_place_gate_matches_over_the_gazetteer(store: Store,
several: dict[str, str]) -> None:
found = gates(store, Gate(field="place", values=["Malmö", "Lund", "oberkochen"],
mode="any"))
# "Remote (SE)" is placed at Sweden, which holds Malmö: no evidence against.
assert {uid for uid, g in found.items() if g == 1} == {
several["malmo"], several["lund"], several["zeiss"]}
several["malmo"], several["lund"], several["zeiss"], several["remote"]}
# ------------------------------------------------------------ unresolved texts
+101 -3
View File
@@ -346,9 +346,89 @@ def test_any_gates_are_one_group_a_role_must_match_one_of(
assert scores[copenhagen][1] == "" and scores[remote_de][1] == ""
assert scores[onsite_de] == (0.0, "none of country DK, remote remote")
assert scores[blank][1] == ""
# "Hybrid" is a country-less line the remote lookup reads as hybrid, so
# the group has evidence against remote and none for country: gated.
assert scores[hybrid_nowhere][1].startswith("none of")
# "Hybrid" is a country-less line the remote lookup reads as hybrid: the
# role may still be in Denmark, so it passes until extract reads it.
assert scores[hybrid_nowhere][1] == ""
def test_an_unknown_location_passes_the_any_group_whatever_its_remote(
store: Store, config: Config, fake: FakeEmbedder) -> None:
"""A place line the gazetteer cannot resolve is no evidence the role is
elsewhere, for the country and for the place gate: the role passes,
hybrid or not. One whose unknown line names a gate value by whole words
matches it, and a role in a resolved place elsewhere is still gated, its
remote unknown or not."""
jobbank = role(store, "1", place="Storkøbenhavn; Udlandet (øvrige)", remote="hybrid")
office = role(store, "2", place="Fleet Place Office", remote="onsite")
avedore = role(store, "3", place="Avedøre Holme")
berlin = role(store, "4", place="Berlin, Germany")
berlin_hybrid = role(store, "5", place="Berlin, Germany", remote="hybrid")
agent = store.save_agent("Malmö, Avedøre or remote", "", [
Gate(field="country", values=["SE"], mode="any"),
Gate(field="remote", values=["remote"], mode="any"),
Gate(field="place", values=["Malmö", "Avedøre Holme"], mode="any")])
run(config, store, score.run_score)
states = {c.uid: c.gates for c in store.score_candidates(agent.id, agent.gates)}
assert states[jobbank] == [-1, 0, -1] and states[office] == [-1, 0, -1]
assert states[avedore] == [-1, -1, 1]
assert states[berlin] == [0, -1, 0]
scores = store.scores(agent.id)
assert all(scores[uid][1] == "" for uid in (jobbank, office, avedore))
reason = "none of country SE, remote remote, place Malmö / Avedøre Holme"
assert scores[berlin] == (0.0, reason) and scores[berlin_hybrid] == (0.0, reason)
def test_a_remote_only_group_still_gates_a_hybrid_role(
store: Store, config: Config, fake: FakeEmbedder) -> None:
"""With no country or place in the group, remote is the only evidence:
a hybrid role is gated, one whose remote is unknown passes."""
hybrid = role(store, "1", place="Headquarters", remote="hybrid")
unknown = role(store, "2", place="Headquarters")
agent = store.save_agent("Remote", "", [Gate(field="remote", values=["remote"], mode="any")])
run(config, store, score.run_score)
scores = store.scores(agent.id)
assert scores[hybrid] == (0.0, "none of remote remote")
assert scores[unknown][1] == ""
def test_a_region_that_holds_the_agents_places_is_no_evidence_against(
store: Store, config: Config, fake: FakeEmbedder) -> None:
"""Øresund holds the Capital Region and Skåne, so a role placed only
there meets a gate on Denmark and one on Copenhagen; Berlin meets
neither. The feed's Place filter still reads only what lies under."""
oresund = role(store, "1", place="Øresundsregionen", remote="onsite")
berlin = role(store, "2", place="Berlin, Germany", remote="onsite")
by_country = store.save_agent("Denmark", "", [
Gate(field="country", values=["DK"], mode="any")])
by_town = store.save_agent("Copenhagen", "", [
Gate(field="place", values=["copenhagen"], mode="any")])
world = store.save_agent("Denmark only", "", [Gate(field="country", values=["DK"])])
run(config, store, score.run_score)
for agent in (by_country, by_town, world):
scores = store.scores(agent.id)
assert scores[oresund][1] == ""
assert scores[berlin][1] != ""
assert oresund not in {r.uid for r in store.roles(places=["country:DK"])}
def test_a_country_that_holds_the_agents_town_is_no_match_for_a_role_placed_elsewhere(
store: Store, config: Config, fake: FakeEmbedder) -> None:
"""Sweden holds Malmö, yet a role in Stockholm is evidence against it."""
stockholm = role(store, "1", place="Stockholm, Sweden", remote="onsite")
malmo = role(store, "2", place="Malmö, Sweden", remote="onsite")
agent = store.save_agent("Malmö", "", [Gate(field="place", values=["Malmö"], mode="any")])
run(config, store, score.run_score)
scores = store.scores(agent.id)
assert scores[stockholm] == (0.0, "none of place Malmö")
assert scores[malmo][1] == ""
def test_failed_gates_reads_evidence_only() -> None:
@@ -365,6 +445,24 @@ def test_failed_gates_reads_evidence_only() -> None:
"none of remote remote, seniority senior"]
def test_an_any_group_with_every_place_member_empty_does_not_fail() -> None:
"""Remote is no evidence against a role whose location is unknown; a
known location elsewhere is, also with remote unknown."""
gates = [Gate(field="country", values=["DK"], mode="any"),
Gate(field="remote", values=["remote"], mode="any"),
Gate(field="place", values=["Malmö"], mode="any")]
def cand(*states: int) -> Candidate:
return Candidate(uid="u", posted_at=NOW.isoformat(), gates=list(states))
assert score.failed_gates(cand(-1, 0, -1), gates) == []
assert score.failed_gates(cand(0, -1, -1), gates) == [
"none of country DK, remote remote, place Malmö"]
assert score.failed_gates(cand(-1, -1, 0), gates) == [
"none of country DK, remote remote, place Malmö"]
remote_only = [Gate(field="remote", values=["remote"], mode="any")]
assert score.failed_gates(cand(0), remote_only) == ["none of remote remote"]
assert score.failed_gates(cand(-1), remote_only) == []
def test_a_gate_is_require_any_or_exclude_and_has_no_weight() -> None:
"""Prefer gates left the agent: hybrid is a feed filter now."""
with pytest.raises(ValidationError):