"""`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 = {"niedersachsen", "norddeutschland", "ostdeutschland", "suddeutschland"} 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 #: `countryplace` 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)]