About 190 German towns (mostly 1KOMMA5°'s) and the German states, French, Italian, Dutch, Asian and other towns, the ISO3 codes and German or French country names boards write. Towns keep their marks through spelling groups. The tests that used Paderborn, Jena and Überlingen as unknown towns use Bopfingen, Lauchheim and Ellwangen instead. Left: names that are no place, ambiguous ones (Halifax, Richmond, Victoria, Durham, Warwick) and bare codes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1202 lines
46 KiB
Python
1202 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:
|
||
germany = {r.key for r in places._GERMANY}
|
||
assert {"niedersachsen", "bayern", "thuringen", "harz"} <= germany
|
||
assert set(REGIONS) == {"skane", "hovedstaden", "zealand", "oresund", "jutland",
|
||
"funen"} | germany
|
||
for key, region in REGIONS.items():
|
||
assert region.key == key and region.label and region.names
|
||
# Germany's are named only; its towns are found through the country.
|
||
assert region.towns or region.includes or key in germany
|
||
|
||
|
||
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)]
|