1198 lines
46 KiB
Python
1198 lines
46 KiB
Python
"""`app.places`: folding, the three token kinds run as SQL, and the suggestions.
|
||
|
||
The rows are `place` strings as boards write them, taken from the live database.
|
||
Each token's SQL runs against an in-memory table shaped like `roles`."""
|
||
|
||
# ruff: noqa: RUF001 (real place strings, with the letters boards write)
|
||
from __future__ import annotations
|
||
|
||
import sqlite3
|
||
|
||
import pytest
|
||
|
||
from app import places
|
||
from app.places import (REGIONS, Suggestion, Token, fold, known, label, match_sql, matches,
|
||
parse, register, suggest)
|
||
|
||
#: (place, country) as a board wrote them and `country_of` read them.
|
||
ROWS = [
|
||
("København", "DK"), ("Copenhagen, Denmark", "DK"), ("Humlebæk, Denmark", "DK"),
|
||
("København K", "DK"), ("København Ø", "DK"), ("Ballerup", "DK"), ("Denmark", "DK"),
|
||
("Aarhus N, Region Central Jutland, Denmark", "DK"), ("Aarhus C, Denmark", "DK"),
|
||
("Billund, Denmark", "DK"), ("Kgs. Lyngby", "DK"), ("Kongens Lyngby", "DK"),
|
||
("Måløv, Capital Region of Denmark, Denmark", "DK"), ("Søborg", "DK"),
|
||
("Kalundborg, Region Zealand, Denmark", "DK"), ("Albertslund", "DK"),
|
||
("Odense, REGION_DNK 1852 South Denmark, Denmark", "DK"), ("Nakskov", "DK"),
|
||
("Nordhavn og mulighed for hjemmearbejde", "DK"), ("Remote OR Copenhagen", "DK"),
|
||
("Malmö", "SE"), ("Lund", "SE"), ("Sweden - Lund", "SE"), ("Helsingborg", "SE"),
|
||
("Malmö, Skåne County, Sweden", "SE"), ("Skåne län, Sweden", "SE"),
|
||
("Höganäs, Sweden", "SE"), ("Stockholm, Sweden", "SE"), ("Gothenburg, Sweden", "SE"),
|
||
("Aarhus, Denmark; København, Denmark; Stockholm, Sweden", "EU"),
|
||
("Copenhagen; London; Warsaw; Milano", "EU"),
|
||
("Copenhagen; Warsaw; New York", ""),
|
||
("Berlin, Germany; Munich, Germany", "DE"), ("Berlin, Germany", "DE"),
|
||
("München", "DE"), ("Munich, Bavaria, Germany", "DE"), ("Köln", "DE"), ("Cologne", "DE"),
|
||
("Zürich", "CH"), ("Zurich, Switzerland", "CH"), ("Genève", "CH"), ("Geneva", "CH"),
|
||
("Wien", "AT"), ("Vienna, Austria", "AT"),
|
||
("Auckland, New Zealand", "NZ"), ("Remote", ""), ("Hybrid", ""), ("Europe", ""),
|
||
("Remote - Denmark", "DK"), ("", ""),
|
||
]
|
||
|
||
|
||
def connect() -> sqlite3.Connection:
|
||
db = sqlite3.connect(":memory:")
|
||
register(db)
|
||
return db
|
||
|
||
|
||
@pytest.fixture()
|
||
def table() -> sqlite3.Connection:
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, ?)",
|
||
[(place, fold(place), country) for place, country in ROWS])
|
||
return db
|
||
|
||
|
||
def found(db: sqlite3.Connection, *tokens: str) -> set[str]:
|
||
"""The places the tokens find, joined with OR as a caller would."""
|
||
parts = [match_sql(token) for token in tokens]
|
||
sql = " OR ".join(sql for sql, _ in parts)
|
||
params = [p for _, params in parts for p in params]
|
||
return {row[0] for row in db.execute(f"SELECT place FROM roles WHERE {sql}", params)}
|
||
|
||
|
||
# ------------------------------------------------------------------- folding
|
||
|
||
|
||
@pytest.mark.parametrize("text, folded", [
|
||
("Skåne län", "skane lan"),
|
||
("København K", "kobenhavn k"),
|
||
("Kgs. Lyngby", "kgs lyngby"),
|
||
("Malmö", "malmo"),
|
||
("Åbyhøj", "abyhoj"),
|
||
("Ærø", "aero"),
|
||
("Düsseldorf", "dusseldorf"),
|
||
("Zürich", "zurich"),
|
||
("Wrocław", "wroclaw"),
|
||
("Höje-Taastrup, Denmark", "hoje taastrup denmark"),
|
||
(" Aarhus N ", "aarhus n"),
|
||
("", ""),
|
||
])
|
||
def test_fold(text: str, folded: str) -> None:
|
||
assert fold(text) == folded
|
||
|
||
|
||
def test_fold_turns_a_ring_and_umlauts_into_the_plain_letter() -> None:
|
||
assert fold("å") == "a"
|
||
assert (fold("ä"), fold("ö"), fold("ü")) == ("a", "o", "u")
|
||
|
||
|
||
# ------------------------------------------------------------------- parsing
|
||
|
||
|
||
def test_parse_reads_the_three_kinds() -> None:
|
||
assert parse("country:DK") == Token("country", "DK", "Denmark")
|
||
assert parse("region:skane") == Token("region", "skane", "Skåne")
|
||
assert parse("place:malmo") == Token("place", "malmo", "Malmö")
|
||
|
||
|
||
def test_parse_reads_bare_text_as_a_place() -> None:
|
||
assert parse("Skåne") == Token("place", "skane", "Skåne")
|
||
assert parse("Kgs. Lyngby").value == "kgs lyngby"
|
||
assert parse("Foo: Bar").kind == "place"
|
||
|
||
|
||
def test_parse_is_forgiving_about_case_and_names() -> None:
|
||
assert parse("Country:dk").value == "DK"
|
||
assert parse("country:Denmark").value == "DK"
|
||
assert parse("region:Skåne").value == "skane"
|
||
assert parse("region:Capital Region of Denmark").value == "hovedstaden"
|
||
assert parse("place:København").value == "kobenhavn"
|
||
|
||
|
||
def test_a_token_round_trips_through_its_string() -> None:
|
||
for text in ("country:DK", "region:oresund", "place:kgs lyngby"):
|
||
assert str(parse(text)) == text
|
||
|
||
|
||
def test_label_reads_a_chip_from_the_address() -> None:
|
||
assert label("country:SE") == "Sweden"
|
||
assert label("region:hovedstaden") == "Capital Region of Denmark"
|
||
assert label("place:kobenhavn") == "København"
|
||
assert label("place:copenhagen") == "Copenhagen"
|
||
assert label("place:malmo") == "Malmö"
|
||
assert label("place:tromso") == "Tromso"
|
||
assert label(parse("place:kgs lyngby")) == "Kgs. Lyngby"
|
||
assert label("country:ZZ") == "ZZ"
|
||
assert label("region:atlantis") == "atlantis"
|
||
|
||
|
||
# ---------------------------------------------------------------------- SQL
|
||
|
||
|
||
def test_a_place_is_matched_on_whole_words(table: sqlite3.Connection) -> None:
|
||
lund = found(table, "place:lund")
|
||
assert lund == {"Lund", "Sweden - Lund"}
|
||
assert "Billund, Denmark" not in lund and "Albertslund" not in lund
|
||
assert found(table, "place:billund") == {"Billund, Denmark"}
|
||
|
||
|
||
def test_a_multi_word_place_is_a_phrase(table: sqlite3.Connection) -> None:
|
||
assert found(table, "place:kgs lyngby") == {"Kgs. Lyngby", "Kongens Lyngby"}
|
||
assert found(table, "place:capital denmark") == set()
|
||
assert found(table, "place:denmark capital") == set()
|
||
|
||
|
||
def test_diacritics_and_spellings_meet(table: sqlite3.Connection) -> None:
|
||
assert found(table, "place:Skåne") == found(table, "place:skane")
|
||
assert "Malmö" in found(table, "place:malmo") and "Malmö" in found(table, "place:Malmö")
|
||
assert {"København", "København K"} <= found(table, "place:kobenhavn")
|
||
|
||
|
||
COPENHAGENS = {"København", "Copenhagen, Denmark", "København K", "Remote OR Copenhagen"}
|
||
|
||
|
||
@pytest.mark.parametrize("spelling", ["copenhagen", "kobenhavn", "kopenhamn", "kopenhagen",
|
||
"København", "Köpenhamn"])
|
||
def test_copenhagen_is_every_spelling(table: sqlite3.Connection, spelling: str) -> None:
|
||
assert found(table, f"place:{spelling}") >= COPENHAGENS
|
||
|
||
|
||
@pytest.mark.parametrize("group", places._ALIAS_GROUPS, ids=lambda g: g[0])
|
||
def test_every_alias_finds_every_other(group: tuple[str, ...]) -> None:
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, '')",
|
||
[(name, fold(name)) for name in group])
|
||
for spelling in group:
|
||
sql, params = match_sql(f"place:{spelling}")
|
||
hit = {r[0] for r in db.execute(f"SELECT place FROM roles WHERE {sql}", params)}
|
||
assert hit == set(group), spelling
|
||
|
||
|
||
def test_no_spelling_belongs_to_two_groups() -> None:
|
||
seen: dict[str, str] = {}
|
||
for group in places._ALIAS_GROUPS:
|
||
for name in group:
|
||
assert seen.setdefault(fold(name), group[0]) == group[0], name
|
||
|
||
|
||
@pytest.mark.parametrize("pair", [("Munich", "München"), ("Cologne", "Köln"),
|
||
("Vienna", "Wien"), ("Zurich", "Zürich"),
|
||
("Geneva", "Genève")])
|
||
def test_a_city_written_two_ways_is_found_either_way(
|
||
table: sqlite3.Connection, pair: tuple[str, str]) -> None:
|
||
one, other = pair
|
||
hit = found(table, f"place:{one}")
|
||
assert hit == found(table, f"place:{other}")
|
||
words = {w for place in hit for w in fold(place).split()}
|
||
assert {fold(one), fold(other)} <= words
|
||
|
||
|
||
def test_aa_and_the_ring_are_one_letter(table: sqlite3.Connection) -> None:
|
||
hit = found(table, "place:århus")
|
||
assert hit == found(table, "place:aarhus") == {
|
||
"Aarhus N, Region Central Jutland, Denmark", "Aarhus C, Denmark",
|
||
"Aarhus, Denmark; København, Denmark; Stockholm, Sweden"}
|
||
|
||
|
||
def test_a_line_with_several_places_is_found_by_each(table: sqlite3.Connection) -> None:
|
||
line = "Aarhus, Denmark; København, Denmark; Stockholm, Sweden"
|
||
for tok in ("place:aarhus", "place:kobenhavn", "place:stockholm", "place:copenhagen"):
|
||
assert line in found(table, tok), tok
|
||
|
||
|
||
def test_several_tokens_are_joined_by_or(table: sqlite3.Connection) -> None:
|
||
hit = found(table, "country:DK", "region:skane")
|
||
assert {"København", "Malmö", "Lund"} <= hit
|
||
assert "Stockholm, Sweden" not in hit
|
||
|
||
|
||
def test_a_country_is_its_code(table: sqlite3.Connection) -> None:
|
||
hit = found(table, "country:DK")
|
||
assert {"København", "Denmark", "Ballerup", "Nakskov", "Odense, REGION_DNK 1852 South Denmark, Denmark"} <= hit
|
||
assert "Malmö" not in hit and "Berlin, Germany" not in hit
|
||
assert "Auckland, New Zealand" not in hit
|
||
|
||
|
||
def test_a_country_is_also_a_line_that_names_it_when_country_is_unset(
|
||
table: sqlite3.Connection) -> None:
|
||
hit = found(table, "country:DK")
|
||
# `country` is EU: a board listing offices in several countries.
|
||
assert "Aarhus, Denmark; København, Denmark; Stockholm, Sweden" in hit
|
||
# Only cities are named, and one of them is Danish.
|
||
assert "Copenhagen; London; Warsaw; Milano" in hit
|
||
assert "Copenhagen; Warsaw; New York" in hit
|
||
# The same words under a country that is set are that country's business.
|
||
assert found(table, "country:SE") >= {"Stockholm, Sweden", "Malmö"}
|
||
assert "Aarhus, Denmark; København, Denmark; Stockholm, Sweden" in found(table, "country:SE")
|
||
assert "Copenhagen, Denmark" in hit # its own country is DK
|
||
|
||
|
||
def test_a_country_name_does_not_reach_a_role_of_another_country() -> None:
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, ?)", [
|
||
("Remote, Denmark", "remote denmark", "GB"), ("Copenhagen", "copenhagen", "DE"),
|
||
("Copenhagen", "copenhagen", "DK"), ("Nowhere, Denmark", "nowhere denmark", "")])
|
||
sql, params = match_sql("country:DK")
|
||
assert db.execute(f"SELECT country FROM roles WHERE {sql} ORDER BY country",
|
||
params).fetchall() == [("",), ("DK",)]
|
||
|
||
|
||
def test_country_eu_is_the_column_alone(table: sqlite3.Connection) -> None:
|
||
assert found(table, "country:EU") == {"Aarhus, Denmark; København, Denmark; Stockholm, Sweden",
|
||
"Copenhagen; London; Warsaw; Milano"}
|
||
|
||
|
||
def test_a_region_is_its_names_and_its_towns(table: sqlite3.Connection) -> None:
|
||
skane = found(table, "region:skane")
|
||
assert skane == {"Malmö", "Lund", "Sweden - Lund", "Helsingborg", "Höganäs, Sweden",
|
||
"Malmö, Skåne County, Sweden", "Skåne län, Sweden"}
|
||
assert found(table, "region:Skåne") == skane
|
||
|
||
hovedstaden = found(table, "region:hovedstaden")
|
||
assert {"København", "København K", "København Ø", "Copenhagen, Denmark", "Ballerup",
|
||
"Humlebæk, Denmark", "Kgs. Lyngby", "Kongens Lyngby", "Søborg", "Albertslund",
|
||
"Måløv, Capital Region of Denmark, Denmark", "Nordhavn og mulighed for hjemmearbejde",
|
||
} <= hovedstaden
|
||
assert not hovedstaden & {"Aarhus C, Denmark", "Billund, Denmark", "Malmö", "Nakskov"}
|
||
|
||
|
||
def test_zealand_is_the_danish_region_and_not_new_zealand(table: sqlite3.Connection) -> None:
|
||
assert found(table, "region:zealand") == {"Kalundborg, Region Zealand, Denmark", "Nakskov"}
|
||
|
||
|
||
def test_jutland_and_funen(table: sqlite3.Connection) -> None:
|
||
assert {"Billund, Denmark", "Aarhus C, Denmark"} <= found(table, "region:jutland")
|
||
assert found(table, "region:funen") == {"Odense, REGION_DNK 1852 South Denmark, Denmark"}
|
||
|
||
|
||
def test_oresund_finds_a_line_of_either_region_but_is_named_by_its_own_words() -> None:
|
||
assert matches("lund sweden", "SE", "region:oresund")
|
||
assert matches("kobenhavn k", "DK", "region:oresund")
|
||
assert not matches("aarhus", "DK", "region:oresund")
|
||
assert "skane" not in {fold(n) for n in REGIONS["oresund"].names}
|
||
assert REGIONS["oresund"].includes == ("hovedstaden", "skane")
|
||
assert parse("region:Capital Region of Denmark").value == "hovedstaden"
|
||
|
||
|
||
def test_oresund_is_the_two_capital_regions(table: sqlite3.Connection) -> None:
|
||
assert found(table, "region:oresund") == (
|
||
found(table, "region:hovedstaden") | found(table, "region:skane"))
|
||
|
||
|
||
def test_a_region_is_a_place_written_as_bare_text(table: sqlite3.Connection) -> None:
|
||
assert found(table, "Skåne") == found(table, "region:skane")
|
||
assert found(table, "place:scania") == found(table, "region:skane")
|
||
assert found(table, "Denmark") == found(table, "country:DK")
|
||
|
||
|
||
def test_a_token_that_names_nothing_finds_nothing(table: sqlite3.Connection) -> None:
|
||
assert found(table, "region:atlantis") == set()
|
||
assert found(table, "place:") == set()
|
||
assert found(table, "") == set()
|
||
assert found(table, "place:nowhere-in-particular") == set()
|
||
|
||
|
||
def test_the_columns_are_the_callers() -> None:
|
||
sql, params = match_sql("country:DK", place="r.pf", country="r.c")
|
||
assert sql == "place_match(r.pf, r.c, ?)" and params == ["country:DK"]
|
||
db = connect()
|
||
db.execute("CREATE TABLE r (pf TEXT, c TEXT)")
|
||
db.executemany("INSERT INTO r VALUES (?, ?)", [("lund", "SE"), ("billund", "DK")])
|
||
sql, params = match_sql("place:lund", place="r.pf", country="r.c")
|
||
assert db.execute(f"SELECT pf FROM r WHERE {sql}", params).fetchall() == [("lund",)]
|
||
|
||
|
||
def test_sql_has_one_parameter_per_question_mark_and_a_token_is_normalised() -> None:
|
||
for token in ("country:DK", "region:oresund", "place:copenhagen", "place:denmark", "Skåne"):
|
||
sql, params = match_sql(token)
|
||
assert sql.startswith("place_match(") and sql.count("?") == len(params) == 1, token
|
||
assert match_sql("country:dk")[1] == ["country:DK"]
|
||
assert match_sql("Kgs. Lyngby")[1] == ["place:kgs lyngby"]
|
||
for token in ("region:atlantis", "country:ZZ", "place:", ""):
|
||
assert match_sql(token) == ("0", []), token
|
||
|
||
|
||
def test_a_wildcard_in_a_value_is_a_letter() -> None:
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, '')", [("a b", "a b"), ("axb", "axb"),
|
||
("a_b", "a_b")])
|
||
for token in ("place:a_b", "place:a%b"):
|
||
sql, params = match_sql(token)
|
||
assert {r[0] for r in db.execute(f"SELECT place FROM roles WHERE {sql}", params)} \
|
||
== {"a b"}, token
|
||
|
||
|
||
def test_known_is_false_for_a_token_that_names_nothing() -> None:
|
||
for token in ("region:atlantis", "country:ZZ", "place:", "region:", "country:", "", ":"):
|
||
assert not known(token), token
|
||
for token in ("country:DK", "country:EU", "country:dk", "region:skane", "region:Skåne",
|
||
"place:nowhere-in-particular", "Skåne", "country:Denmark"):
|
||
assert known(token), token
|
||
|
||
|
||
def test_matches_is_false_for_a_token_that_names_nothing() -> None:
|
||
assert not matches("copenhagen", "DK", "region:atlantis")
|
||
assert not matches("copenhagen", "ZZ", "country:ZZ")
|
||
assert not matches("copenhagen", "DK", "place:")
|
||
|
||
|
||
def test_null_columns_match_nothing_and_do_not_raise() -> None:
|
||
db = connect()
|
||
assert db.execute("SELECT place_match(NULL, NULL, 'place:lund')").fetchone() == (0,)
|
||
assert db.execute("SELECT place_match(NULL, 'DK', 'country:DK')").fetchone() == (1,)
|
||
|
||
|
||
# ----------------------------------------------------------------- the tables
|
||
|
||
|
||
def test_every_region_has_names_and_towns() -> None:
|
||
assert set(REGIONS) == {"skane", "hovedstaden", "zealand", "oresund", "jutland", "funen"}
|
||
for key, region in REGIONS.items():
|
||
assert region.key == key and region.label and region.names
|
||
assert region.towns or region.includes
|
||
|
||
|
||
def test_the_bare_word_zealand_is_no_name_since_new_zealand_has_it() -> None:
|
||
assert "zealand" not in places._PHRASES["zealand"]
|
||
|
||
|
||
def test_the_capital_and_scanian_towns_are_in_their_regions() -> None:
|
||
skane = {fold(t) for t in REGIONS["skane"].towns}
|
||
assert {"malmo", "lund", "helsingborg", "kristianstad", "landskrona", "trelleborg",
|
||
"angelholm", "hassleholm", "ystad", "eslov", "hoganas", "staffanstorp", "lomma",
|
||
"bjuv", "burlov", "kavlinge", "svedala", "vellinge"} <= skane
|
||
hoved = {fold(t) for t in REGIONS["hovedstaden"].towns}
|
||
assert {"kobenhavn", "kgs lyngby", "soborg", "ballerup", "malov", "bagsvaerd", "humlebaek",
|
||
"smorum", "nordhavn", "frederiksberg", "hillerod", "helsingor"} <= hoved
|
||
|
||
|
||
# ----------------------------------------------------------------- suggestions
|
||
|
||
PLACES = [
|
||
("København", "DK", 69), ("Copenhagen, Denmark", "DK", 56), ("København K", "DK", 35),
|
||
("København Ø", "DK", 34), ("Kgs. Lyngby", "DK", 16), ("Billund, Denmark", "DK", 18),
|
||
("Aarhus N, Region Central Jutland, Denmark", "DK", 26), ("Albertslund", "DK", 10),
|
||
("Denmark", "DK", 27), ("Remote OR Copenhagen", "DK", 1),
|
||
("Malmö", "SE", 214), ("Lund", "SE", 127), ("Sweden - Lund", "SE", 29),
|
||
("Malmö, Skåne County, Sweden", "SE", 3), ("Stockholm, Sweden", "SE", 287),
|
||
("Aarhus, Denmark; København, Denmark; Stockholm, Sweden", "EU", 1),
|
||
("Remote", "", 40), ("Hybrid", "", 12), ("Europe", "EU", 20), ("", "", 5),
|
||
("Berlin, Germany", "DE", 100), ("Auckland, New Zealand", "NZ", 25),
|
||
("The Hague, Netherlands", "NL", 9), ("Den Haag", "NL", 4),
|
||
("Copenhagen Office", "DK", 16), ("Copenhagen Hub - Løvstræde", "DK", 14),
|
||
("DK-Copenhagen-MSO", "DK", 2),
|
||
("Munich", "DE", 40), ("München", "DE", 10), ("Munich Office", "DE", 5),
|
||
("Munich (DE)", "DE", 3), ("Munich - Berlin", "DE", 2),
|
||
("Garching bei München (Munich)", "DE", 4), ("Kalundborg, Region Zealand, Denmark", "DK", 14),
|
||
]
|
||
|
||
|
||
def tokens(q: str, **kw) -> list[str]:
|
||
return [s.token for s in suggest(q, PLACES, **kw)]
|
||
|
||
|
||
def test_skane_is_suggested_however_it_is_typed() -> None:
|
||
for q in ("Skåne", "skane", "SKANE", "ska", "Scania", "scan"):
|
||
assert "region:skane" in tokens(q), q
|
||
hit = next(s for s in suggest("skane", PLACES) if s.token == "region:skane")
|
||
assert hit == Suggestion("region:skane", "Skåne", "region", 214 + 127 + 29 + 3)
|
||
|
||
|
||
def test_a_country_counts_the_roles_that_carry_its_code() -> None:
|
||
hit = suggest("den", PLACES)[0]
|
||
assert hit == Suggestion("country:DK", "Denmark", "country",
|
||
69 + 56 + 35 + 34 + 16 + 18 + 26 + 10 + 27 + 1
|
||
+ 16 + 14 + 2 + 14)
|
||
assert tokens("swe")[0] == "country:SE"
|
||
assert tokens("sverige")[0] == "country:SE"
|
||
assert tokens("danmark")[0] == "country:DK"
|
||
|
||
|
||
def test_countries_come_first_then_regions_then_towns() -> None:
|
||
kinds = [s.kind for s in suggest("den", PLACES)]
|
||
assert kinds == sorted(kinds, key=["country", "region", "place"].index)
|
||
assert kinds[0] == "country" and "region" in kinds and kinds[-1] == "place"
|
||
|
||
|
||
def test_towns_are_grouped_and_labelled_by_their_commonest_spelling() -> None:
|
||
lund = [s for s in suggest("lund", PLACES) if s.kind == "place"]
|
||
assert lund == [Suggestion("place:lund", "Lund", "place", 127 + 29)]
|
||
kbh = [s for s in suggest("kob", PLACES) if s.kind == "place"]
|
||
assert kbh[0].label == "København" and kbh[0].token == "place:kobenhavn"
|
||
|
||
|
||
def test_a_postal_district_is_not_a_town_of_its_own() -> None:
|
||
labels = [s.label for s in suggest("kob", PLACES) if s.kind == "place"]
|
||
assert "København K" not in labels and "København Ø" not in labels
|
||
assert [s.label for s in suggest("aarhus", PLACES) if s.kind == "place"] == ["Aarhus"]
|
||
|
||
|
||
def test_spellings_of_one_town_are_one_suggestion() -> None:
|
||
towns = [s for s in suggest("cop", PLACES) if s.kind == "place"]
|
||
assert len(towns) == 1
|
||
# København, K and Ø, the one in a list of three towns; Copenhagen, and "Remote OR Copenhagen".
|
||
assert towns[0].label == "København" and towns[0].count == 69 + 35 + 34 + 1 + 56 + 1 + 16 + 14 + 2
|
||
assert [s.token for s in suggest("kobenhavn", PLACES) if s.kind == "place"] \
|
||
== [towns[0].token]
|
||
|
||
|
||
def test_only_the_first_comma_part_of_each_semicolon_part_is_a_town() -> None:
|
||
labels = {s.label for q in "abcdefghijklmnopqrstuvwxyz"
|
||
for s in suggest(q, PLACES, limit=999) if s.kind == "place"}
|
||
assert {"Aarhus", "Stockholm", "Malmö", "Lund", "Berlin"} <= labels
|
||
assert not {"Denmark", "Sweden", "Region Central Jutland", "Remote", "Hybrid", "Europe"} \
|
||
& labels
|
||
|
||
|
||
def test_remote_hybrid_and_country_names_are_no_town() -> None:
|
||
for q in ("rem", "hyb", "eur", "denm"):
|
||
assert [s for s in suggest(q, PLACES) if s.kind == "place"] == [], q
|
||
|
||
|
||
def test_a_word_prefix_finds_a_multi_word_town() -> None:
|
||
assert tokens("haag") == tokens("hague") == tokens("den haag") == tokens("the hag") \
|
||
== ["place:the hague"]
|
||
assert tokens("kgs ly") == ["place:kgs lyngby"]
|
||
assert tokens("lyngby") == ["place:kgs lyngby"]
|
||
|
||
|
||
def test_the_word_must_start_not_end() -> None:
|
||
assert "place:lund" not in tokens("und")
|
||
assert "place:billund" not in tokens("lund")
|
||
assert "place:albertslund" not in tokens("lund")
|
||
|
||
|
||
def test_a_country_or_region_with_no_open_role_is_not_suggested() -> None:
|
||
assert tokens("zea")[:1] == ["country:NZ"]
|
||
assert "region:zealand" in tokens("zea") # Kalundborg
|
||
assert "region:funen" not in tokens("fun") # no Funen role in PLACES
|
||
assert "country:AU" not in tokens("aus") # no role of its own
|
||
|
||
|
||
def test_limit_and_the_empty_query() -> None:
|
||
assert suggest("", PLACES) == [] and suggest(" ", PLACES) == [] and suggest("---", PLACES) == []
|
||
assert len(suggest("a", PLACES, limit=3)) == 3
|
||
assert len(suggest("a", PLACES)) <= 12
|
||
|
||
|
||
def test_towns_are_ordered_by_roles() -> None:
|
||
towns = [s for s in suggest("l", PLACES) if s.kind == "place"]
|
||
assert [s.count for s in towns] == sorted((s.count for s in towns), reverse=True)
|
||
|
||
|
||
def test_suggest_takes_any_iterable() -> None:
|
||
assert suggest("lund", iter(PLACES)) == suggest("lund", PLACES)
|
||
|
||
|
||
def test_a_suggested_token_finds_the_roles_it_counted(table: sqlite3.Connection) -> None:
|
||
for s in suggest("kob", PLACES) + suggest("lund", PLACES) + suggest("skane", PLACES):
|
||
assert parse(s.token).kind == s.kind
|
||
assert found(table, s.token), s.token
|
||
assert label(s.token) == s.label or s.kind == "place"
|
||
|
||
|
||
# ------------------------------------------------- the function against LIKE
|
||
|
||
#: `country<TAB>place` of open roles on the live database, distinct: a random
|
||
#: sample plus, for each token below, lines that hold it. Some lines have no country.
|
||
REAL = """
|
||
NL 's-Hertogenbosch, Netherlands
|
||
3 Locations
|
||
5 Locations
|
||
DK Aabenraa eller København
|
||
DK Aalborg, Copenhagen, Kolding, Aarhus, Hybrid position
|
||
DK Aalborg, Denmark; Aarhus, Denmark; Copenhagen, Denmark; Odense, Denmark; Søborg, Denmark
|
||
DK Aarhus C, Denmark
|
||
DK Aarhus N, Denmark
|
||
DK Aarhus or Valby
|
||
EU Aarhus, Denmark; København, Denmark; Stockholm, Sweden
|
||
Aix-en-Provence
|
||
DK Allerød or Stockholm (SE)
|
||
DK Allerød, Copenhagen, or Stockholm, Hybrid position
|
||
KZ Almaty, Almatı oblısı, Kazakhstan
|
||
EU Amsterdam, Netherlands; Berlin, Germany; København, Denmark; Vilnius, Lithuania
|
||
EU Amsterdam, Netherlands; Berlin, Germany; Munich, Germany; Remote, Germany
|
||
EU Amsterdam, Netherlands; Manchester, United Kingdom
|
||
EU Amsterdam; Germany
|
||
FR Angers, France
|
||
DE Ansbach, Mittelfranken, Germany
|
||
MX Apaseo el Grande, GUANAJUATO, Mexico
|
||
US Arizona; California; Washington
|
||
NL Arnhem, GELDERLAND, Netherlands
|
||
BE Asse, , Belgium
|
||
Athens, Greece; Cyprus; Frankfurt am Main, Germany; Munich, Germany; Tel Aviv, Israel
|
||
Athens, Greece; London, United Kingdom; Tel Aviv, Israel
|
||
Auckland
|
||
US Austin; New York City; Palo Alto
|
||
AU Australian Capital Territory, Australia
|
||
DK Bad Homburg; Copenhagen
|
||
DK Bagsværd
|
||
DK Ballerup or Aarhus V
|
||
DK Ballerup, , Denmark
|
||
DK Ballerup, Ballerup
|
||
DK Ballerup, Denmark
|
||
IN Bangalore, KA, India
|
||
CN Bao Ding, Hebei, China
|
||
ES Barcelona, Catalonia
|
||
EU Barcelona, Spain; Stockholm, Stockholm County, Sweden
|
||
EU Barcelona; Berlin; London; Munich; Paris
|
||
EU Barcelona; Geneva
|
||
DE Barsinghausen, Germany
|
||
PL Bartoszyce, Warminsko-mazurskie, Poland
|
||
MY Bayan lepas, Pulau Pinang, Malaysia
|
||
EU Belgium; Netherlands
|
||
RS Belgrade - Savski Venac, Serbia
|
||
EU Belgrade, Serbia; Berlin, Germany; Munich, Germany
|
||
US Bellevue, United States of America
|
||
US Bellevue, WA, United States
|
||
US Bellevue, Washington; Denver, Colorado; Seattle, Washington; Washington, D.C.
|
||
IN Bengaluru, India
|
||
RS Beograd, , Serbia
|
||
NO Bergen, , Norway
|
||
NL Berkel en Rodenrijs, ROTTERDAM, Netherlands
|
||
DE Berlin Office; Munich Office
|
||
DE Berlin Office; Munich Office; Remotely in Germany
|
||
DE Berlin, Berlin, Germany
|
||
DE Berlin, Germany
|
||
EU Berlin, Germany; Amsterdam, Netherlands; Copenhagen, Denmark
|
||
EU Berlin, Germany; Copenhagen, Denmark
|
||
EU Berlin, Germany; London, United Kingdom
|
||
EU Berlin, Germany; London, United Kingdom; Stockholm, Sweden
|
||
EU Berlin, Germany; Munich, Germany; Prague, Czech Republic
|
||
EU Berlin, Germany; Paris, France
|
||
DE Berlin; Cologne; Frankfurt; Hamburg; Munich; Stuttgart
|
||
DE Berlin; Frankfurt; Munich
|
||
DE Berlin; Frankfurt; Munich; Stuttgart
|
||
EU Berlin; London; Munich
|
||
EU Berlin; London; Munich; Paris
|
||
EU Berlin; London; Munich; Paris; Stockholm; Tallinn
|
||
DE Berlin; Munich
|
||
CH Bern, Switzerland
|
||
NL Best, Noord-Brabant, Netherlands
|
||
DE Bietigheim-Bissingen, Baden-Württemberg, Germany
|
||
DK Billund Kornmarken, Denmark
|
||
DK Billund, Denmark
|
||
DK Billund, København
|
||
DK Billund, København K
|
||
DK Billund; Copenhagen Hub - Løvstræde
|
||
EU Billund; London; Copenhagen Hub - Løvstræde
|
||
DK Birkerød
|
||
SE Bjuv
|
||
DK Bjæverskov
|
||
DE Bochum, NW, Germany
|
||
DE Bonn, Germany
|
||
FR Bordeaux
|
||
JP Bosch Corporation_Shibuya_BGSJ, Tokyo, Japan
|
||
US Boston, MA, United States
|
||
US Bozeman, MT, United States
|
||
DK Brabrand, Denmark
|
||
Brest
|
||
US Bridgewater, United States of America
|
||
FR Briey, France
|
||
GB Bristol, UK; London, UK
|
||
SI Brnik - Aerodrom, , Slovenia
|
||
DK Bronshoj, Denmark
|
||
BE Bruxelles, Bruxelles, Belgium
|
||
DK Brøndby
|
||
DK Brøndby eller Fredericia
|
||
DK Brøndby eller Fredericia og mulighed for hjemmearbejde
|
||
US Burlington, United States
|
||
Busan
|
||
DE Butzbach, HE, Germany
|
||
RO Buzau, Com Caragele, Constanta, Romania
|
||
SE Båstad
|
||
DE Böblingen, Baden-Württemberg, Germany
|
||
CA CA-Toronto
|
||
AU Camberwell, Australia
|
||
GB Carlisle, England, United Kingdom
|
||
DE Carlsfelder Str. 3, 06188 Land, Germany
|
||
DE Castroper Hellweg 109, 44805 B, Germany
|
||
MX Celaya Planta, GUANAJUATO, Mexico
|
||
US Cement, United States
|
||
Chandigarh
|
||
CN Chengdu, Sichuan, China; XiAn, Shaanxi, China
|
||
FR Cherbourg-en-Cotentin, Manche, France
|
||
US Chicago, Atlanta, US-Remote, Toronto
|
||
CL Chile
|
||
China - Hong Kong; Taiwan - Taipei
|
||
MX Ciudad de México, CDMX, Mexico
|
||
MX Colon, QUERETARO, Mexico
|
||
DK Copenhagen
|
||
DK Copenhagen Hub - Løvstræde, Denmark
|
||
DK Copenhagen Hub - Løvstræde; Billund
|
||
DK Copenhagen Hub - Østergade, Denmark
|
||
DK Copenhagen K, Denmark; Aarhus C, Denmark
|
||
DK Copenhagen O, Denmark
|
||
DK Copenhagen Office
|
||
DK Copenhagen S, Region Capital of Denmark, Denmark
|
||
DK Copenhagen V, Denmark
|
||
DK Copenhagen V, Denmark; Aarhus C, Denmark
|
||
DK Copenhagen or Aarhus
|
||
Copenhagen, Denmark; Tel Aviv, Israel
|
||
DK Copenhagen, Hovedstaden, Denmark
|
||
DK Copenhagen; Billund LEGO Campus
|
||
Copenhagen; Zurich; Singapore; Warsaw; Toronto
|
||
AR Corrientes, , Argentina
|
||
Corte Madera
|
||
NL Culemborg, Netherlands
|
||
Curitiba
|
||
PE Cusco, Cusco, Peru
|
||
DE DE Store Hamburg Spitalerstraße, Germany
|
||
US Dallas, United States
|
||
AU Dandenong South, VICTORIA, Australia
|
||
GB Darlington, England, United Kingdom
|
||
AU Deakin ACT, Australia
|
||
EU Denmark; Vilnius, Lithuania
|
||
DK Dianalund
|
||
CN Dongguan, Guangdong, China
|
||
DE Dortmund, Germany
|
||
DE Dortmund, North Rhineland Westphalia, DE +1 more…
|
||
IE Dublin, CA (ZICC)
|
||
EU Dublin, Ireland; London
|
||
GB Dublin, United Kingdom
|
||
Dunkerque
|
||
Durban
|
||
EU EMEA; Germany; London, United Kingdom; Paris, France; Remote - Netherlands
|
||
DE Ergolding, BY, Germany
|
||
DK Esbjerg, Region South Denmark, Denmark
|
||
DE Eschborn, HE, Germany
|
||
DE Eschenburg, HE, Germany
|
||
Ezhou
|
||
IT Fagagna, , Italy
|
||
GB Farnborough, Hampshire, United Kingdom
|
||
DK Farum
|
||
DK Finland, København, Litauen, Polen, Sverige
|
||
EU Finland; France; Germany; Netherlands; Remote - Europe; Sweden; United Kingdom
|
||
EU Finland; Remote - Denmark; Stockholm, Sweden
|
||
Finland; United Kingdom; Korea, Republic of; Denmark; France; India; Poland; United States
|
||
Finland; United Kingdom; United States; Belgium
|
||
DE Fins Only-DE-Munich-MSO
|
||
EU Fleet Place Office; Amsterdam Office; Berlin Office
|
||
France; India; Finland
|
||
DE Frankfurt; Berlin; Munich
|
||
DE Frankfurt; Munich
|
||
DK Fredericia or Ballerup
|
||
DK Fredericia, REGION_DNK 1852 South Denmark, Denmark
|
||
DK Frederiksberg
|
||
DK Frederikssund og mulighed for hjemmearbejde
|
||
DK Fårevejle
|
||
GB GB-London
|
||
US Garden City, TX, United States
|
||
EU Geneva; London
|
||
DE Gerlingen, Baden-Württemberg, Germany
|
||
DE Germany Scoober Office
|
||
EU Germany, Remote; The Netherlands, Remote
|
||
Germany; Portugal; Canada; United States
|
||
DK Glostrup
|
||
DK Glostrup, Denmark
|
||
PL Goleniów, Województwo zachodniopomorskie, Poland
|
||
US Greenville, South Carolina, United States, South Carolina, United States of America
|
||
PL Grodzisk Mazowiecki (mazowieckie), Poland
|
||
SE Göteborg, Västra Götaland, Sweden; Lund, Skåne, Sweden
|
||
AT Haag, Austria
|
||
DE Hannover, NDS, Germany
|
||
VN Hanoi, , Vietnam
|
||
DK Headquarters, Denmark
|
||
US Heber, AZ, United States
|
||
SE Helsingborg, Sweden
|
||
FI Helsinki Metropolitan Area
|
||
FI Helsinki, Finland
|
||
EU Helsinki, Finland; Stockholm, Sweden; Tallinn, Estonia
|
||
DK Herlev og mulighed for hjemmearbejde
|
||
DE Herzogenrath, North Rhine Westphalia, Germany
|
||
DE Hildesheim, NDS, Germany
|
||
DK Hillerød
|
||
DK Hillerød, Capital Region of Denmark, Denmark
|
||
DE Hoher Hagen 3, 58513 Lüdensche, Germany
|
||
DK Holbæk
|
||
DE Homburg, , Germany
|
||
DE Homburg/Saar, SL, Germany
|
||
EU Home Based - Americas; Home Based - APAC; Home based - EMEA; Home based - Worldwide
|
||
GB Home Based - Americas; Home based - EMEA; Office Based - London, UK
|
||
MX Home-based, Mexico
|
||
DK Hvalsø
|
||
DK Hvidovre
|
||
Hwaseong-si
|
||
Hybrid
|
||
GB Hybrid - London, England
|
||
IN Hyderabad; Noida
|
||
SE Härryda, Sweden
|
||
SE Hässleholm
|
||
SE Höör
|
||
JP Ibaraki, Osaka, Japan
|
||
US Illinois, USA, Remote; Minnesota, USA, Remote
|
||
DE Immenstadt im Allgäu, BY, Germany
|
||
Indija
|
||
IT Induno Olona, Italy
|
||
Israel; Remote - Europe; United Kingdom
|
||
DE Jacob-A.-Morand-Str. 18, 07552, Germany
|
||
JP Japan, Tokyo
|
||
Jena
|
||
CZ Jihlava 1, Kraj Vysočina, Czechia
|
||
NL Joure, Netherlands
|
||
DK Kalundborg, Region Zealand, Denmark
|
||
DK Kastrup
|
||
SE Katrineholm, Sweden
|
||
DE Kelsterbach, HE, Germany
|
||
Kempten im Allgäu
|
||
IL Kfar Saba, Israel
|
||
Konstanz
|
||
SE Kristianstad, Sweden
|
||
MY Kuala Lumpur – Co-labs, Kuala Lumpur – Co-labs, Malaysia
|
||
MY Kuala Lumpur, Malaysia
|
||
SE Kungsängen, Sweden
|
||
BE Kuurne, Belgium
|
||
DK København
|
||
DK København K
|
||
DK København K eller Odense C
|
||
DK København K og mulighed for hjemmearbejde
|
||
DK København NV
|
||
DK København S
|
||
DK København SV eller Aalborg og mulighed for hjemmearbejde
|
||
DK København SV, Odense C
|
||
DK København V eller Korsør
|
||
DK København V og mulighed for hjemmearbejde
|
||
DK København Ø og Frederiksberg C samt mulighed for hjemmearbejde
|
||
DK København Ø, Denmark
|
||
EU København, Capital RegionDenmark, Denmark; Moss, Østfold, Norway; Oslo, Oslo, Norway
|
||
DK København, Denmark
|
||
DK København, Denmark; Aarhus, Denmark; Aalborg, Denmark; Kolding, Denmark
|
||
DK København, Denmark; Aarhus, Denmark; Kolding, Denmark; Aalborg, Denmark
|
||
EU København, Denmark; Stockholm, Sweden
|
||
DK København, København SV
|
||
DK København, København SV, Odense, Odense C
|
||
DK København, København SV, Viby J, Aarhus
|
||
DK København, Roskilde
|
||
DK Køge
|
||
DK Køge, Denmark
|
||
ES La Muela (Zaragoza), Z, Spain
|
||
La Roche-sur-Yon
|
||
US Lake Zurich, Illinois, United States
|
||
SE Landskrona
|
||
EU Lausanne; London
|
||
DK Lem St, Denmark
|
||
DK Lem St, Region Central Jutland, Denmark
|
||
NL Lemelerveld, Netherlands
|
||
MX León, GUA, Mexico
|
||
IT Liguria, Italy
|
||
DE Lohr am Main, BY, Germany
|
||
SE Lomma
|
||
London, Canada; Remote, United States; Oak Brook, United States
|
||
GB London, London, United Kingdom
|
||
London, Paris, Toronto, New York
|
||
EU London, United Kingdom; Oslo, Norway
|
||
London, United Kingdom; Remote, United States
|
||
GB London; Billund Project House
|
||
EU London; Copenhagen
|
||
GB London; Remote (UK)
|
||
EU London; Warsaw; Copenhagen
|
||
EU London; Zurich
|
||
SE Luleå, Sweden
|
||
SE Lund, Skåne län, Sweden
|
||
SE Lund, Skåne, Sweden
|
||
US Madison, Wisconsin, United States of America
|
||
SE Malmo, Sweden
|
||
SE Malmö
|
||
SE Malmö, Skåne County, Sweden
|
||
SE Malmö, Skåne Län, Sweden
|
||
SE Malmö, Sweden
|
||
DK Maribo
|
||
DE Meschede, Nordrhein-Westfalen, Germany
|
||
Metz
|
||
US Miami
|
||
US Miami, Florida, United States
|
||
DK Middelfart, Denmark
|
||
AU Midland, Australia
|
||
IT Milan Office
|
||
EU Milan, Italy; Paris, Paris, France
|
||
US Minneapolis, Minnesota, United States, Minnesota, United States of America
|
||
US Minneola, KS, United States
|
||
Monterrey
|
||
MX Monterrey, Mexico
|
||
US Mountain View, CA, USA; San Francisco, CA, USA
|
||
US Mountain View, California
|
||
US Mountain View, California; Plano, Texas; San Francisco, California
|
||
DE Munich
|
||
EU Munich - Berlin - London - Paris
|
||
EU Munich - Berlin - London - Paris - Warsaw - Tallinn
|
||
EU Munich - Berlin - Paris
|
||
DE Munich, Bavaria, Germany
|
||
DK Munkebo, Denmark
|
||
LU Munsbach, Luxembourg
|
||
Mátészalka
|
||
Möhnesee
|
||
DE München
|
||
DE München (DE)
|
||
DE München, BAYERN, Germany
|
||
DE München, BY, Germany
|
||
DE München, Germany
|
||
US NYC
|
||
US NYC, SF, Chi, Remote
|
||
Nagpur
|
||
DK Nakskov, Denmark
|
||
DK Nakskov, Region Zealand, Denmark
|
||
Nanjing
|
||
JP Nasushiobara, Tochigi, Japan
|
||
GB New Britain
|
||
New York City, Toronto, Chicago, or Remote
|
||
US New York, San Francisco, Seattle, Atlanta, Chicago
|
||
New York; Hong Kong; London; Singapore; Sydney
|
||
RS Niš, Serbia
|
||
DK Nordhavn eller Aalborg og mulighed for hjemmearbejde
|
||
DK Nordhavn eller Viby J
|
||
DK Nordhavn or Åbyhøj
|
||
NO Norway
|
||
AU Nundah, Australia
|
||
SE Nybro, Sweden
|
||
DK Nykøbing F
|
||
DK Nykøbing F, Denmark
|
||
DK Næstved
|
||
DK Nørre Asmindrup
|
||
DE Nürnberg
|
||
CA ON, Toronto, Canada
|
||
DE Oberkochen; München
|
||
PL Oborniki, Poland
|
||
DK Odense C, Denmark
|
||
DK Odense M, Denmark
|
||
DK Odense, Denmark
|
||
DK Odense, REGION_DNK 1852 South Denmark, Denmark
|
||
GB Office Based - London, UK
|
||
TW Office Based - Taipei, Taiwan
|
||
US Oklahoma, United States
|
||
CA Ontario - Remote
|
||
US Ontario, CA, United States of America
|
||
US Orange County , California, United States
|
||
SE Oskarshamn, Sweden
|
||
EU Paris, France; Copenhagen, Denmark; Amsterdam, Netherlands; Berlin, Germany
|
||
FR Paris, France; Tassin-la-Demi-Lune, France; Bordeaux, France
|
||
EU Paris;Geneva
|
||
US Paw Paw, IL, United States
|
||
FR Perigny, France
|
||
FR Perpignan, Pyrénées-Orientales, France
|
||
SE Perstorp
|
||
US Phillipsburg, New Jersey, United States
|
||
DE Pinkertweg 16, 22113 Hamburg, Germany
|
||
MX Planta Celaya, , Mexico
|
||
EU Poland; Hungary
|
||
PT Porto, Portugal
|
||
EU Porto, Portugal; Madrid, Spain; Berlin, Germany
|
||
CZ Prague
|
||
EC Quito, , Ecuador
|
||
DK Randers SV, København V or Krakow
|
||
GB Redhill (GB)
|
||
DK Region Hovedstaden
|
||
DK Region Sjælland
|
||
IL Rehovot, Israel
|
||
AU Remote - Australia
|
||
CA Remote - CAN British Columbia
|
||
Remote - Portugal; United States
|
||
US Remote - USA WA, United States of America
|
||
US Remote - United States
|
||
DK Remote OR Copenhagen
|
||
US Remote US MD, United States of America
|
||
Remote job
|
||
Remote, AMER
|
||
Remote, Canada; Remote, Poland; Remote, United Kingdom; Remote, United States
|
||
Remote, Canada; Remote, United Kingdom; Remote, US
|
||
EU Remote, Germany; Dublin, Ireland; Lisbon, Portugal
|
||
US Remote, US, Georgia
|
||
US Remote, Washington, USA, United States of America
|
||
BG Remote- Bulgaria
|
||
Remote-NORAM
|
||
US Remote-US
|
||
RS Remote; Serbia
|
||
DE Remscheid
|
||
CA Retail Store Chinook Ctr, Canada
|
||
US Retail Store Ontario Mills, United States of America
|
||
HR Rijeka, Croatia
|
||
DK Ringkøbing, Denmark
|
||
DK Ringsted
|
||
DK Ringsted, Ringsted
|
||
BR Rio de Janeiro, Brasil
|
||
DE Rosenheim
|
||
DK Roskilde
|
||
DK Roskilde og mulighed for hjemmearbejde
|
||
DK Roskilde, Denmark
|
||
PL Rosówek, Poland
|
||
Roßdorf
|
||
AU Ryde, Australia
|
||
DE Röntgenstr. 33, 32107 Bad Salz, Germany
|
||
DK Rønne or Køge
|
||
Saint-Etienne
|
||
Saint-Malo
|
||
US San Bernardino, California, United States, California, United States of America
|
||
US San Francisco, CA; Washington, DC
|
||
US San Francisco, Seattle, New York, Chicago, Remote in the US
|
||
CR San Jose, Costa Rica
|
||
HN San Pedro Sula, , Honduras
|
||
MT San Ġwann, Malta
|
||
DE Schwäbisch Gmünd, BW, Germany
|
||
US Seattle, Washington, United States
|
||
US Seattle, Washington, United States, Washington, United States of America
|
||
US Seymour, United States
|
||
CN Shanghai, Shanghai, China; Suzhou, Jiangsu, China
|
||
PL Siedlc, Poland
|
||
SE Sigtuna, Sweden
|
||
SG Singapore - Singapore
|
||
SG Singapore, SG
|
||
DK Slagelse
|
||
SE Sollentuna, Sweden
|
||
SE Solna
|
||
BR Sorocaba, SP, Brazil
|
||
DK Sorø
|
||
GB Southampton, England, United Kingdom
|
||
SE Staffanstorp
|
||
US Stamford, Connecticut, United States, Connecticut, United States of America
|
||
SE Stockholm HQ
|
||
SE Stockholm, Stockholm County, Sweden
|
||
EU Stockholm, Stockholm County, Sweden; London, London, United Kingdom; Barcelona, Spain
|
||
SE Stockholm, Stockholm County, Sweden; Malmö, Sweden
|
||
EU Stockholm, Sweden; Berlin, Germany
|
||
EU Stockholm, Sweden; Jorvas, Kirkkonummi, Finland
|
||
EU Stockholm; London; Milan; Warsaw
|
||
CZ Strakonice, Czechia
|
||
SE Svedala
|
||
SE Sweden
|
||
SE Sweden - Linköping
|
||
SE Sweden - Lund
|
||
GB Swindon, United Kingdom
|
||
AU Sydney Or Melbourne
|
||
US Syracuse, New York, United States, New York, United States of America
|
||
PT São João, Aveiro, Portugal
|
||
SE Södertälje, Sweden
|
||
DK Taastrup
|
||
DK Taastrup og mulighed for hjemmearbejde
|
||
TW Taichung, Taichung City, Taiwan
|
||
TW Taipei, Taiwan, Taiwan
|
||
Taipei; Geneva
|
||
CN Taiyuan, Shanxi, China
|
||
EE Tallinn, Estonia
|
||
GE Tbilisi, Georgia
|
||
MX Tecnoparque, Mexico City, Mexico; Santa Fe, Mexico City, Mexico; Mexico City, Mexico
|
||
MX Tepotzotlan, Estado de México, Mexico
|
||
US The Woodlands, United States of America
|
||
RO Timisoara, Romania
|
||
GB Tiverton, United Kingdom
|
||
SE Tomelilla
|
||
MX Tonalá, Mexico
|
||
Tonsley SA
|
||
Toronto, New York, San Francisco, Atlanta, Seattle
|
||
PL Toruń, PM, Poland
|
||
PL Toruń, Poland
|
||
SE Trelleborg
|
||
Troisdorf
|
||
NO Trondheim, Norway
|
||
Tunis
|
||
DE Tübingen (DE)
|
||
US US-IL-Chicago-MSO
|
||
USA (Remote), Spain (Remote), UK (Remote)
|
||
US USA - IL - Chicago, United States of America
|
||
US USA - UT - Remote, United States of America
|
||
GB United Kingdom Remote
|
||
EU United Kingdom; Paris, Ile-de-France, France
|
||
United States; Stockholm, Sweden; Melbourne, Victoria, Australia
|
||
United States; Sweden
|
||
CN Urumqi, Xinjiang, China
|
||
FR Valbonne, Provence-Alpes-Côte d'Azur, France
|
||
DK Valby, Aalborg
|
||
DK Vallensbæk Strand
|
||
CA Vancouver
|
||
Vannes
|
||
FI Vantaa, Uusimaa, Finland
|
||
SE Varberg, Sweden
|
||
SE Vellinge
|
||
US Vernon Hills, IL, United States
|
||
DK Vi søger i hele landet
|
||
US Victorville, California, United States
|
||
DK Videbæk, Denmark
|
||
DK Videbæk, Region Central Jutland, Denmark
|
||
EU Vilnius, Lithuania; Copenhagen K, Denmark
|
||
EU Vilnius, Lithuania; Copenhagen V, Denmark
|
||
DK Værløse
|
||
EU Warsaw, Poland; Vilnius, Lithuania
|
||
PL Warszawa
|
||
AU Wensleydale, VIC, Australia
|
||
DE Wiesbaden, HE, Germany
|
||
CA Windsor, Canada
|
||
US Windsor, United States
|
||
GB Worksop, UK
|
||
Wuhan
|
||
CN XiAn, Shaanxi, China
|
||
SE Ystad
|
||
CN Zhuhai, Guangdong, China
|
||
SE Älmhult, Sweden
|
||
SE Ängelholm
|
||
SE Ängelholm, Sweden
|
||
SE Åby, Sweden
|
||
DK Åbyhøj eller Ballerup
|
||
SE Örebro, Sweden
|
||
SE Östra Göinge
|
||
CN 东莞, , China
|
||
"""
|
||
|
||
LINES = [tuple(reversed(line.split("\t", 1))) for line in REAL.strip("\n").split("\n")]
|
||
|
||
#: The tokens of every kind that are known. (`country:ZZ` and the rest that name
|
||
#: nothing are `known` false and match nothing, which the old LIKE did not say.)
|
||
ORACLE_TOKENS = [
|
||
"country:DK", "country:SE", "country:DE", "country:GB", "country:US", "country:EU",
|
||
"country:NO", "country:CH",
|
||
"region:skane", "region:hovedstaden", "region:zealand", "region:oresund",
|
||
"region:jutland", "region:funen",
|
||
"place:copenhagen", "place:kobenhavn", "place:malmo", "place:lund", "place:munich",
|
||
"place:zurich", "place:london", "place:remote", "place:aarhus", "place:kgs lyngby",
|
||
"place:the hague", "place:scania", "place:capital region of denmark",
|
||
"place:denmark", "place:germany", "place:skane", "Skåne", "Berlin",
|
||
]
|
||
|
||
|
||
def like_words(column: str, phrases) -> tuple[str, list]:
|
||
"""The clause `match_sql` was before it called a function: each phrase a
|
||
`LIKE` over the padded column. Slow, and the definition `matches` must keep."""
|
||
phrases = [p for p in dict.fromkeys(phrases) if p]
|
||
clause = f"' ' || {column} || ' ' LIKE ? ESCAPE '\\'"
|
||
return " OR ".join([clause] * len(phrases)) or "0", [f"% {p} %" for p in phrases]
|
||
|
||
|
||
def like_country(code: str) -> tuple[str, list]:
|
||
names, params = like_words("place_fold", places._COUNTRY_MENTIONS.get(code, ()))
|
||
if not params:
|
||
return "country = ?", [code]
|
||
return f"country = ? OR (country IN ('', 'EU') AND ({names}))", [code, *params]
|
||
|
||
|
||
def like_sql(token: str) -> tuple[str, list]:
|
||
tok = parse(token)
|
||
if tok.kind == "country":
|
||
sql, params = like_country(tok.value)
|
||
elif tok.kind == "region":
|
||
sql, params = like_words("place_fold", places._PHRASES[tok.value])
|
||
else:
|
||
region = places._REGION_BY_NAME.get(tok.value, "")
|
||
sql, params = like_words("place_fold", [*places._expand(tok.value),
|
||
*places._PHRASES.get(region, ())])
|
||
if tok.value in places._COUNTRY_BY_NAME:
|
||
more, extra = like_country(places._COUNTRY_BY_NAME[tok.value])
|
||
sql, params = f"{sql} OR {more}", [*params, *extra]
|
||
return f"({sql})", params
|
||
|
||
|
||
@pytest.fixture(scope="module")
|
||
def real() -> sqlite3.Connection:
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, ?)",
|
||
[(place, fold(place), country) for place, country in LINES])
|
||
return db
|
||
|
||
|
||
def test_there_are_enough_real_lines() -> None:
|
||
assert len(set(LINES)) >= 300
|
||
assert {"DK", "SE", "DE", "EU", ""} <= {country for _, country in LINES}
|
||
|
||
|
||
@pytest.mark.parametrize("token", ORACLE_TOKENS)
|
||
def test_matches_agrees_with_the_like_it_replaces(real: sqlite3.Connection, token: str) -> None:
|
||
sql, params = like_sql(token)
|
||
by_like = {row[0] for row in real.execute(
|
||
f"SELECT rowid FROM roles WHERE {sql}", params)}
|
||
by_function = {row[0] for row in real.execute(
|
||
"SELECT rowid, place_fold, country FROM roles") if matches(row[1], row[2], token)}
|
||
assert by_function == by_like, token
|
||
sql, params = match_sql(token)
|
||
assert {row[0] for row in real.execute(
|
||
f"SELECT rowid FROM roles WHERE {sql}", params)} == by_like
|
||
|
||
|
||
@pytest.mark.parametrize("kind, tokens", [
|
||
("country", [t for t in ORACLE_TOKENS if t.startswith("country:")]),
|
||
("region", [t for t in ORACLE_TOKENS if t.startswith("region:")]),
|
||
("place", [t for t in ORACLE_TOKENS if t.startswith("place:")]),
|
||
])
|
||
def test_each_kind_finds_something_in_the_real_lines(real: sqlite3.Connection, kind: str,
|
||
tokens: list[str]) -> None:
|
||
"""Agreement on nothing would prove little: most tokens hit, some lines do not."""
|
||
hits = [sum(matches(fold(place), country, t) for place, country in LINES) for t in tokens]
|
||
assert sum(1 for n in hits if n) >= len(tokens) * 0.75, (kind, hits)
|
||
assert all(n < len(LINES) for n in hits)
|
||
|
||
|
||
def test_a_region_over_thousands_of_lines_is_fast() -> None:
|
||
"""The reason `matches` is a function: 160 `LIKE` clauses took 400 ms per query.
|
||
The bound is generous, a machine under load is not the test's business."""
|
||
import time
|
||
|
||
db = connect()
|
||
db.execute("CREATE TABLE roles (place TEXT, place_fold TEXT, country TEXT)")
|
||
rows = [(f"{place} {i}", fold(f"{place} {i}"), country)
|
||
for i in range(10) for place, country in LINES]
|
||
db.executemany("INSERT INTO roles VALUES (?, ?, ?)", rows)
|
||
assert len(rows) >= 5000
|
||
for token in ("region:oresund", "region:hovedstaden", "region:skane", "country:DK"):
|
||
sql, params = match_sql(token)
|
||
start = time.perf_counter()
|
||
n = db.execute(f"SELECT count(*) FROM roles WHERE {sql}", params).fetchone()[0]
|
||
assert time.perf_counter() - start < 0.5, token
|
||
assert n > 0
|
||
|
||
|
||
# --------------------------------------------- what is suggested, and on what
|
||
|
||
|
||
def test_oresund_is_not_suggested_for_the_names_of_the_regions_it_holds() -> None:
|
||
for q in ("ska", "skane", "den", "capital", "hoved", "scania"):
|
||
assert "region:oresund" not in tokens(q), q
|
||
for q in ("ore", "øre", "oresund", "öresund"):
|
||
assert "region:oresund" in tokens(q), q
|
||
|
||
|
||
def test_a_region_is_suggested_on_its_own_names() -> None:
|
||
assert tokens("ska")[:1] == ["region:skane"]
|
||
assert "region:hovedstaden" in tokens("den")
|
||
assert "region:zealand" in tokens("den") or "region:zealand" in tokens("zea")
|
||
|
||
|
||
def test_a_line_that_holds_a_town_counts_under_it() -> None:
|
||
munich = [s for s in suggest("mun", PLACES) if s.kind == "place"]
|
||
assert [s.token for s in munich] == ["place:munich"]
|
||
# Munich 40, München 10, Office 5, (DE) 3, Munich - Berlin 2, Garching (Munich) 4.
|
||
assert munich[0].count == 40 + 10 + 5 + 3 + 2 + 4
|
||
assert munich[0].label == "Munich"
|
||
|
||
|
||
def test_a_line_that_holds_two_towns_counts_under_both() -> None:
|
||
berlin = [s for s in suggest("ber", PLACES) if s.kind == "place"]
|
||
assert [(s.label, s.count) for s in berlin] == [("Berlin", 100 + 2)]
|
||
|
||
|
||
def test_copenhagen_with_an_office_or_a_hub_is_copenhagen() -> None:
|
||
towns = [s for s in suggest("cope", PLACES) if s.kind == "place"]
|
||
assert [s.token for s in towns] == ["place:kobenhavn"]
|
||
assert towns[0].count == 69 + 35 + 34 + 1 + 56 + 1 + 16 + 14 + 2
|
||
for text in ("Copenhagen Office", "Hub", "MSO"):
|
||
assert all(text not in s.label for s in towns)
|
||
|
||
|
||
def test_a_town_the_tables_do_not_know_stays_as_it_is() -> None:
|
||
labels = {s.label for q in "abcdefghijklmnopqrstuvwxyz"
|
||
for s in suggest(q, PLACES, limit=999) if s.kind == "place"}
|
||
assert {"Albertslund", "Billund", "Auckland"} <= labels
|
||
assert not {"Copenhagen Office", "Munich Office", "Munich - Berlin", "Munich (DE)"} & labels
|
||
|
||
|
||
def test_a_line_that_is_only_a_known_town_in_a_word_is_not_a_hit_for_another() -> None:
|
||
"""`Lund` is not in `Billund`: a line holds a town as whole words or not at all."""
|
||
assert [s.label for s in suggest("lund", PLACES) if s.kind == "place"] == ["Lund"]
|
||
|
||
|
||
def test_a_bar_separates_places_like_a_semicolon() -> None:
|
||
rows = [("Denmark | Remote", "DK", 1), ("Lund | Malmö", "SE", 2)]
|
||
assert [s.label for s in suggest("den", rows) if s.kind == "place"] == []
|
||
assert [(s.label, s.count) for s in suggest("mal", rows) if s.kind == "place"] \
|
||
== [("Malmö", 2)]
|