"""Text normalisation for the AMLC 2026 business entity resolution pipeline. Pure standard library (``re`` + ``unicodedata``). Public API: fix_encoding(s) -> str repair mojibake / C1 controls / zero-width chars clean_text(s, strip_prefixes=True) -> str generic cleaner (accents, junk, punctuation) normalize_name(s, country='') -> NameNorm normalize_address(s, country) -> AddrNorm normalize_record(name, address, country)-> dict flat dict of both + blocking keys blocking_keys(name_norm, addr_norm, country, token_df=None) -> list[str] transliterate_indic(s) -> None stub, filled by a later module blocking_normalizer(df) -> polars DataFrame adapter for src.blocking --normalizer Design notes ------------ * ``country`` is an open string set. Every country-specific behaviour is a dict lookup (``_COUNTRY_CFG.get(key, default)``); an unseen country falls back to generic rules, never errors. * Accent folding strips only *Latin* combining marks (U+0300-036F etc.), so Indic vowel signs and viramas survive and Indic words are not broken. * Names: legal forms are removed from ``core`` wherever they sit (start, end, middle, bracketed, reordered, doubled); generic words (services, center, group ...) stay in ``core``. Alias forms "X f/k/a Y", "X dba Y", "X formerly: Y" ... -> ``alt_names=[X, Y]`` and ``core=Y`` (in this data Y is the real / S1 name and X a generated brand). * Addresses: parts are classified (street / unit / other / district / state / numeric / null) and put in canonical order street, unit, other, district, state. ``city`` is the last "other" part (= the middle part of a 3-part address). French région names and département names are *recognised* (région -> ``state``, département -> ``district``) but never mapped to each other. """ from __future__ import annotations import re import unicodedata from collections import Counter from dataclasses import dataclass, field from functools import lru_cache __all__ = [ "NameNorm", "AddrNorm", "fix_encoding", "fold_accents", "clean_text", "normalize_name", "normalize_address", "normalize_record", "blocking_keys", "transliterate_indic", "country_key", "blocking_normalizer", ] # ---------------------------------------------------------------------------------------------- # 1. Encoding repair # ---------------------------------------------------------------------------------------------- # 'Â\x80\x93' / 'â\x80\x99': UTF-8 bytes of U+2013 / U+2019 decoded as latin-1 (first byte mangled). _MOJIBAKE_RE = re.compile("[\u00c2\u00e2]\u0080([\u0080-\u00bf])") _MOJIBAKE_THIRD = { 0x90: "-", 0x91: "-", 0x92: "-", 0x93: "-", 0x94: "-", 0x95: "-", 0x98: "'", 0x99: "'", 0x9a: "'", 0x9b: "'", 0x9c: '"', 0x9d: '"', 0x9e: '"', } # Same thing decoded as cp1252 instead of latin-1 ('’'): cheap to cover as well. _CP1252_MOJIBAKE = {"\u00e2\u20ac\u2122": "'", "\u00e2\u20ac\u02dc": "'", "\u00e2\u20ac\u201c": "-", "\u00e2\u20ac\u201d": "-", "\u00e2\u20ac\u0153": '"'} _CHAR_FIX = { # C1 controls read as cp1252 punctuation; everything else in U+0080-009F is dropped **{cp: None for cp in range(0x80, 0xA0)}, 0x80: " ", 0x82: ",", 0x84: '"', 0x85: " ", 0x8B: " ", 0x91: "'", 0x92: "'", 0x93: '"', 0x94: '"', 0x95: " ", 0x96: "-", 0x97: "-", 0x9B: " ", # zero-width / invisible 0x200B: None, 0x200C: None, 0x200D: None, 0x2060: None, 0xFEFF: None, 0x00AD: None, # spaces, quotes, dashes, slashes 0x00A0: " ", 0x2007: " ", 0x202F: " ", 0x3000: " ", 0x2018: "'", 0x2019: "'", 0x201A: "'", 0x201B: "'", 0x2032: "'", 0x00B4: "'", 0x0060: "'", 0x201C: '"', 0x201D: '"', 0x201E: '"', 0x00AB: '"', 0x00BB: '"', 0x2010: "-", 0x2011: "-", 0x2012: "-", 0x2013: "-", 0x2014: "-", 0x2015: "-", 0x2212: "-", 0x2044: "/", 0x2215: "/", 0x00B0: "o", # 'N°' -> 'No' ('Nº' already becomes 'No' under NFKD) } def fix_encoding(s: str) -> str: """Repair double-encoded punctuation, C1 control characters and zero-width characters.""" if not s: return "" if s.isascii(): return s if "\u0080" in s: s = _MOJIBAKE_RE.sub(lambda m: _MOJIBAKE_THIRD.get(ord(m.group(1)), " "), s) if "\u20ac" in s: for bad, good in _CP1252_MOJIBAKE.items(): s = s.replace(bad, good) return s.translate(_CHAR_FIX) # ---------------------------------------------------------------------------------------------- # 2. Accent folding (Latin only) # ---------------------------------------------------------------------------------------------- _LATIN_COMBINING_RE = re.compile("[\u0300-\u036f\u1ab0-\u1aff\u1dc0-\u1dff\u20d0-\u20ff\ufe20-\ufe2f]") _SPECIAL_LETTERS = str.maketrans({"ß": "ss", "æ": "ae", "œ": "oe", "ø": "o", "đ": "d", "ł": "l", "ı": "i", "þ": "th", "ð": "d", "ŀ": "l"}) _INDIC_RE = re.compile("[\u0900-\u0dff]") def fold_accents(s: str) -> str: """NFKD + strip Latin combining marks. 'Résorts' -> 'Resorts', 'Fïls' -> 'Fils'. Indic untouched.""" if s.isascii(): return s s = unicodedata.normalize("NFKD", s) s = _LATIN_COMBINING_RE.sub("", s) return s.translate(_SPECIAL_LETTERS).translate(_CHAR_FIX) # NFKD can emit U+2044 etc. def _prep(s: str) -> str: """fix_encoding + lowercase + accent fold.""" return fold_accents(fix_encoding(s).lower()) # ---------------------------------------------------------------------------------------------- # 3. Punctuation / token helpers shared by names and addresses # ---------------------------------------------------------------------------------------------- def _build_punct_table() -> dict: table = {} for cp in range(0, 0x10000): if 0xD800 <= cp <= 0xDFFF: continue ch = chr(cp) if ch in "/-": continue cat = unicodedata.category(ch) if cat[0] in "PS" or cat == "Cc": table[cp] = " " return table _PUNCT_TABLE = _build_punct_table() _ACRONYM_RE = re.compile(r"(? sarl _APOS_RE = re.compile(r"['\"]") _ELISION_SPACE_RE = re.compile(r"(? "l'egalite" _WWW_RE = re.compile(r"\b(?:https?://)?www\.") _DOMAIN_SUFFIX_RE = re.compile(r"(?<=[a-z0-9])\.(?:c[o0]m|co\.in|in|fr|net|org)\b") _NULL_TOKEN_RE = re.compile(r"<\s*null\s*>|\bnull\b") _HAS_DIGIT_RE = re.compile(r"\d") _DIGITS_RE = re.compile(r"\d+") _SEP_RUN_RE = re.compile(r"([-/])[-/]+") _SEP_WORD_DIGIT_RE = re.compile(r"(?<=[a-z]{3})[-/](?=\d)|(?<=\d)[-/](?=[a-z]{3})|(?<=[a-z])[-/](?=[a-z])") _SEP_ANY_RE = re.compile(r"[-/]+") def _split_separators(text: str) -> list: """Whitespace-split; '-' and '/' become spaces unless inside a token that carries a digit ('C-6/24/1', '20/20' kept). Inside digit tokens, a >=3-letter word is split off ('sector-19' -> 'sector 19') while short prefixes stay ('dl-126').""" out = [] for tok in text.split(): if "-" not in tok and "/" not in tok: out.append(tok) continue tok = tok.strip("-/") if not tok: continue if not _HAS_DIGIT_RE.search(tok): out.extend(p for p in _SEP_ANY_RE.split(tok) if p) continue tok = _SEP_RUN_RE.sub(r"\1", tok) out.extend(p.strip("-/") for p in _SEP_WORD_DIGIT_RE.sub(" ", tok).split() if p.strip("-/")) return out def _dedupe_adjacent(toks: list) -> list: """Drop immediately repeated alphabetic tokens ('Family Family Health', 'Unit UNIT 4').""" out = [] for t in toks: if out and t == out[-1] and not t[:1].isdigit(): continue out.append(t) return out def _to_tokens(s: str) -> list: """Shared punctuation pipeline on an already lower-cased / folded string.""" s = _ACRONYM_RE.sub(lambda m: m.group(1).replace(".", ""), s) if "'" in s: s = _ELISION_SPACE_RE.sub(r"\1'", s) s = _APOS_RE.sub("", s) s = s.translate(_PUNCT_TABLE) return _split_separators(s) # ---------------------------------------------------------------------------------------------- # 4. clean_text (generic) # ---------------------------------------------------------------------------------------------- _JUNK_EDGE_RE = re.compile(r"^(?:\s|--+|<<+|>>+|\|+|#+|\*+|!+)+|(?:\s|--+|<<+|>>+|\|+|#+|\*+|!+)+$") _PREFIX_RE = re.compile(r"^(?:m\s*/\s*s\b\.?|messrs\b\.?|dr\b\.?)\s*") _ID_RE = re.compile(r"\(\s*id\s*:?\s*\d+\s*\)|(?:(?<=\s)|^)#\d{3,}(?=\s|$)") _PIPE_DOMAIN_TAIL_RE = re.compile(r"\s*\|\s*(?:https?://)?(?:www\.)?[a-z0-9.\-]+\.(?:c[o0]m|co\.in|in|fr|net|org)\s*$") def clean_text(s: str, strip_prefixes: bool = True) -> str: """Generic cleaner: encoding repair, NFKD + strip accents, lowercase, '&' -> 'and', junk markers ('--', '<<', '>>', '|', '#', '##', '***') removed, brackets -> inner text, 'www.' and trailing '.com/.in/.fr/.c0m' stripped, 'null' dropped, leading 'm/s' / 'dr' dropped (strip_prefixes), punctuation -> spaces except '-' and '/' inside digit-bearing tokens.""" if not s: return "" s = _prep(s) s = _ID_RE.sub(" ", s) s = _PIPE_DOMAIN_TAIL_RE.sub("", s) s = _JUNK_EDGE_RE.sub("", s) if strip_prefixes: s = _PREFIX_RE.sub("", s) s = _WWW_RE.sub("", s) s = _DOMAIN_SUFFIX_RE.sub("", s) s = _NULL_TOKEN_RE.sub(" ", s) s = s.replace("&", " and ").replace("#", " ") return " ".join(_to_tokens(s)) # ---------------------------------------------------------------------------------------------- # 5. Country handling (open set) # ---------------------------------------------------------------------------------------------- _COUNTRY_ALIASES = { "us": "us", "usa": "us", "u s": "us", "u s a": "us", "united states": "us", "united states of america": "us", "america": "us", "india": "india", "in": "india", "ind": "india", "bharat": "india", "france": "france", "fr": "france", "fra": "france", "republique francaise": "france", } @lru_cache(maxsize=1024) def country_key(country) -> str: """Canonical lowercase key. Known aliases collapse ('USA' -> 'us'); anything else is kept as its own folded lowercase string, so new countries flow through generic rules.""" if not country: return "" k = " ".join(_prep(str(country)).replace(".", " ").split()) return _COUNTRY_ALIASES.get(k, k) # ---------------------------------------------------------------------------------------------- # 6. Names # ---------------------------------------------------------------------------------------------- STRONG, EDGE, SUFFIX, PAIR = "strong", "edge", "suffix", "pair" # token -> (canonical, kind). STRONG: removed anywhere. EDGE: removed at either edge / next to a # legal token / right before a trailing generic word. SUFFIX ('private', 'public'): right edge, # next to a legal token, or anywhere once ltd/limited is present. PAIR: only before ltd/limited. _LEGAL_COMMON = { "inc": ("inc", STRONG), "incorporated": ("inc", STRONG), "corp": ("corp", STRONG), "corporation": ("corp", STRONG), "co": ("co", EDGE), "company": ("co", EDGE), "llc": ("llc", STRONG), "ltd": ("ltd", STRONG), "limited": ("ltd", STRONG), "llp": ("llp", STRONG), "pllc": ("pllc", STRONG), "pc": ("pc", STRONG), "plc": ("plc", STRONG), "lp": ("lp", STRONG), "pvt": ("pvt", STRONG), "private": ("pvt", SUFFIX), "opc": ("opc", EDGE), "public": ("public", SUFFIX), } _LEGAL_FRANCE = { "sarl": ("sarl", STRONG), "sas": ("sas", STRONG), "sasu": ("sasu", STRONG), "eurl": ("eurl", STRONG), "sa": ("sa", EDGE), "sci": ("sci", EDGE), "snc": ("snc", EDGE), "scp": ("scp", EDGE), "ei": ("ei", EDGE), "scop": ("scop", EDGE), "gie": ("gie", EDGE), "ets": ("ets", EDGE), "etablissements": ("ets", EDGE), "etablissement": ("ets", EDGE), } # Indic-script spellings seen in S2/S3 India names (limited / private / pra. / li. / LLP). _LEGAL_INDIC_RAW = { "ltd": ["लिमिटेड", "लि", "లిమిటెడ్", "ಲಿಮಿಟೆಡ್", "லிமிடெட்", "লিমিটেড", "લિમિટેડ", "લિ", "ലിമിറ്റഡ്", "ଲିମିଟେଡ୍", "ਲਿਮਟਿਡ", "ਲਿਮਿਟੇਡ", "ਲਿ"], "pvt": ["प्राइवेट", "प्रा", "ప్రైవేట్", "ಪ್ರೈವೇಟ್", "பிரைவேட்", "প্রাইভেট", "પ્રાઇવેટ", "પ્રા", "പ്രൈവറ്റ്", "ପ୍ରାଇଭେଟ୍", "ਪ੍ਰਾਈਵੇਟ", "ਪ੍ਰਾ"], "llp": ["एलएलपी", "ఎల్ఎల్పీ", "ಎಲ್ಎಲ್ಪಿ", "எல்எல்பி", "એલએલપી", "এলএলপি", "എൽഎൽപി", "ଏଲ୍ଏଲ୍ପି"], } _LEGAL_INDIC = {} for _canon, _words in _LEGAL_INDIC_RAW.items(): for _w in _words: _kind = SUFFIX if _canon == "pvt" else STRONG _LEGAL_INDIC[_prep(_w)] = (_canon, _kind) _LEGAL_BY_COUNTRY = { "us": {**_LEGAL_COMMON, **_LEGAL_INDIC}, "india": {**_LEGAL_COMMON, **_LEGAL_INDIC}, "france": {**_LEGAL_COMMON, **_LEGAL_FRANCE, **_LEGAL_INDIC}, } _LEGAL_DEFAULT = {**_LEGAL_COMMON, **_LEGAL_FRANCE, **_LEGAL_INDIC} _LEGAL_ORDER = ["public", "pvt", "opc", "ltd", "llp", "llc", "pllc", "inc", "corp", "co", "pc", "plc", "lp", "sarl", "sasu", "sas", "eurl", "sa", "sci", "snc", "scp", "scop", "ei", "gie", "ets"] _LEGAL_RANK = {c: i for i, c in enumerate(_LEGAL_ORDER)} # Generic words vendors append ("... Co Services", "... Inc Center"); they stay in core but let an # EDGE legal token right before them be recognised. _GENERIC_TAIL = frozenset( "services service center centre group partners enterprises trading authority board council " "association commission trust foundation society federation ventures industries solutions " "systems holdings international global associates".split()) _HONORIFICS = frozenset("the mr mrs ms dr smt shri sri messrs".split()) _EDGE_FILLERS = frozenset(["and"]) _ALIAS_RE = re.compile( r"\s+(?:f\s*/\s*k\s*/\s*a|fka|formerly\s+known\s+as|formerly|d\s*/\s*b\s*/\s*a|d\.b\.a\.?|dba" r"|doing\s+business\s+as|a\s*/\s*k\s*/\s*a|a\.k\.a\.?|aka|also\s+known\s+as|trading\s+as|t\s*/\s*a" r"|n[\u00e9]e)\s*:?\s+") # 'née' only when accented: plain 'nee' is a common surname _DOMAIN_RE = re.compile(r"^(?:https?://)?(?:www\.)?([a-z0-9][a-z0-9.\-]*?)\.(?:c[o0]m|co\.in|in|fr|net|org|biz|info)$") _HANDLE_RE = re.compile(r"^[@#]([a-z0-9_.]{3,})$") _ORDINAL_RE = re.compile(r"^\d+(?:st|nd|rd|th)$") _LEET = str.maketrans({"0": "o", "1": "l", "3": "e", "4": "a", "5": "s", "6": "g", "7": "t", "8": "b"}) _LEET_DIGITS = frozenset("01345678") _LEET_SHORT = {"c0": "co", "0f": "of", "t0": "to"} _PLUS_AND_RE = re.compile(r"\s\+\s") # 'Marshall + Perry' == 'Marshall & Perry'; 'V+ Select' untouched _CODE_TOKEN_RE = re.compile(r"^\d+[a-z]$|^[a-z]\d+$") # '68a', 'a206': house/unit codes, not leet _NON_ALNUM_RE = re.compile(r"[^a-z0-9]") def _deleet(tok: str) -> str: """Undo look-alike digit substitution in name tokens: '6yan'->'gyan', '50ftware'->'software', 'c0rp'->'corp', 'l1c'->'llc', 'lnc'->'inc'. Leaves numbers, ordinals, 'b2b', 'a206', '68a'.""" if tok.startswith("ln") and len(tok) > 2 and tok[2:].isalpha(): return "i" + tok[1:] if tok.isalpha() or tok.isdigit() or not tok.isascii(): return tok if tok in _LEET_SHORT: return _LEET_SHORT[tok] digits = [c for c in tok if c.isdigit()] letters = sum(c.isalpha() for c in tok) if (letters < 2 or len(digits) > 2 or not all(d in _LEET_DIGITS for d in digits) or not tok.isalnum() or _ORDINAL_RE.match(tok) or _CODE_TOKEN_RE.match(tok)): return tok return tok.translate(_LEET) def _overlap(a: str, b: str) -> float: return sum((Counter(a) & Counter(b)).values()) / max(len(a), len(b)) def _fuzzy_legal_word(tok: str): """Scrambled 'private' / 'limited' ('Pivaet', 'Pricivate', 'Lmiietd'). Requires the first letter plus the word's distinctive letters so 'printers', 'pirates', 'limits' do not match.""" if len(tok) < 5 or len(tok) > 10 or not tok.isalpha(): return None if tok[0] == "p" and "v" in tok and _overlap(tok, "private") >= 0.7: return "private" if tok[0] == "l" and "m" in tok and "d" in tok and _overlap(tok, "limited") >= 0.7: return "limited" return None def _extract_legal(tokens: list, table: dict): """Return (core_tokens, sorted canonical legal forms).""" n = len(tokens) if n == 0: return [], [] info = [table.get(t) for t in tokens] # scrambled legal words: 'private' right before ltd/limited, 'limited' at the end or after pvt for i, t in enumerate(tokens): if info[i] is None and n > 1 and t[:1] in ("p", "l"): w = _fuzzy_legal_word(t) if w == "private" and i + 1 < n and info[i + 1] and info[i + 1][0] == "ltd": info[i] = table.get("private") elif w == "limited" and (i == n - 1 or (i > 0 and info[i - 1] and info[i - 1][0] == "pvt")): info[i] = table.get("limited") legal = [bool(x and x[1] == STRONG) for x in info] # 'private' anywhere once a ltd/limited is present ('Private Asian Transcripts Ltd') if any(x and x[0] == "ltd" and legal[i] for i, x in enumerate(info)): for i, x in enumerate(info): if x and x[1] == SUFFIX: legal[i] = True # PAIR ('public') only directly before ltd/limited for i, x in enumerate(info): if x and x[1] == PAIR and i + 1 < n and info[i + 1] and info[i + 1][0] == "ltd": legal[i] = True changed = True while changed: changed = False rest = [i for i in range(n) if not legal[i]] if len(rest) <= 1: break lo, hi = rest[0], rest[-1] x = info[lo] if x and x[1] == EDGE: legal[lo] = changed = True continue x = info[hi] if x and x[1] in (EDGE, SUFFIX): legal[hi] = changed = True continue # EDGE/SUFFIX token adjacent to an already-legal token ('Pvt Ltd', 'SAS Etablissements') for i in rest: x = info[i] if x and x[1] in (EDGE, SUFFIX) and ((i > 0 and legal[i - 1]) or (i + 1 < n and legal[i + 1])): legal[i] = changed = True break if changed: continue # EDGE/SUFFIX token right before a trailing generic word ('Associates Co Services') if len(rest) >= 3 and tokens[hi] in _GENERIC_TAIL: j = rest[-2] x = info[j] if x and x[1] in (EDGE, SUFFIX): legal[j] = changed = True core = [t for t, is_l in zip(tokens, legal) if not is_l] forms = sorted({info[i][0] for i in range(n) if legal[i]}, key=lambda c: _LEGAL_RANK.get(c, 99)) if not core: # name made only of legal words: keep them as core core = list(tokens) while len(core) > 1 and core[0] in _EDGE_FILLERS: core.pop(0) while len(core) > 1 and core[-1] in _EDGE_FILLERS: core.pop() return core, forms def _name_segment(seg: str, table: dict): """Normalise one already fix_encoded + lower-cased name segment. Returns (core_tokens, legal_forms, is_domain_form, full_tokens).""" s = fold_accents(seg) s = _ID_RE.sub(" ", s) s = _PIPE_DOMAIN_TAIL_RE.sub("", s).strip() # domain / handle form: 'shylabrothersprivate.com', 'viprivate.c0m', '#BUSHSANTORO', '@rapidquality' m = _HANDLE_RE.match(s) if not m: s = _JUNK_EDGE_RE.sub("", s).strip() s = _PREFIX_RE.sub("", s).strip() s = _JUNK_EDGE_RE.sub("", s).strip() m = _DOMAIN_RE.match(s) if (s and " " not in s) else None if m: label = _deleet(_NON_ALNUM_RE.sub("", m.group(1))) if label: return [label], [], True, [label] s = _WWW_RE.sub("", s) s = _DOMAIN_SUFFIX_RE.sub("", s) s = _NULL_TOKEN_RE.sub(" ", s) s = _PLUS_AND_RE.sub(" and ", s).replace("&", " and ").replace("+", " ").replace("#", " ") toks = _dedupe_adjacent([_deleet(t) for t in _to_tokens(s)]) while len(toks) > 1 and toks[0] in _HONORIFICS: toks.pop(0) if len(toks) > 2 and toks[0] == "m" and toks[1] == "s": # 'M S' left from an unusual 'M/s' toks = toks[2:] core, legal = _extract_legal(toks, table) return core, legal, False, toks @dataclass class NameNorm: core: str = "" # legal form(s) removed, generic words kept legal: str = "" # canonical legal form(s): 'llc', 'pvt ltd', 'sarl ets', '' tokens: list = field(default_factory=list) spaceless: str = "" # core without spaces (char n-grams vs domain forms) alt_names: list = field(default_factory=list) # cores of X and Y in 'X f/k/a Y' forms is_domain_form: bool = False # 'duttainternationalschool.com', '#BUSHSANTORO' has_indic_script: bool = False full: str = "" # cleaned name including legal words def transliterate_indic(s: str): """Stub: Indic-script -> Latin transliteration is provided by a later module.""" return None @lru_cache(maxsize=1 << 18) def _normalize_name_cached(raw: str, ck: str): table = _LEGAL_BY_COUNTRY.get(ck, _LEGAL_DEFAULT) s = fix_encoding(raw).lower() has_indic = bool(_INDIC_RE.search(s)) alts = () m = _ALIAS_RE.search(s) if m: x, y = s[: m.start()], s[m.end():] cx, lx, dx, fx = _name_segment(x, table) cy, ly, dy, fy = _name_segment(y, table) if cx and cy: alts = tuple(dict.fromkeys([" ".join(cx), " ".join(cy)])) core, legal, dom, full = cy, (ly or lx), dy, fx + fy return (" ".join(core), " ".join(legal), tuple(core), alts, dom, has_indic, " ".join(full)) core, legal, dom, full = _name_segment(s, table) return (" ".join(core), " ".join(legal), tuple(core), alts, dom, has_indic, " ".join(full)) def normalize_name(s: str, country: str = "") -> NameNorm: if not s: return NameNorm() core, legal, toks, alts, dom, indic, full = _normalize_name_cached(s, country_key(country)) return NameNorm(core=core, legal=legal, tokens=list(toks), spaceless=core.replace(" ", ""), alt_names=list(alts), is_domain_form=dom, has_indic_script=indic, full=full) # ---------------------------------------------------------------------------------------------- # 7. Addresses: gazetteers (recognition only) # ---------------------------------------------------------------------------------------------- _US_STATES = { "al": "alabama", "ak": "alaska", "az": "arizona", "ar": "arkansas", "ca": "california", "co": "colorado", "ct": "connecticut", "de": "delaware", "fl": "florida", "ga": "georgia", "hi": "hawaii", "id": "idaho", "il": "illinois", "in": "indiana", "ia": "iowa", "ks": "kansas", "ky": "kentucky", "la": "louisiana", "me": "maine", "md": "maryland", "ma": "massachusetts", "mi": "michigan", "mn": "minnesota", "ms": "mississippi", "mo": "missouri", "mt": "montana", "ne": "nebraska", "nv": "nevada", "nh": "new hampshire", "nj": "new jersey", "nm": "new mexico", "ny": "new york", "nc": "north carolina", "nd": "north dakota", "oh": "ohio", "ok": "oklahoma", "or": "oregon", "pa": "pennsylvania", "ri": "rhode island", "sc": "south carolina", "sd": "south dakota", "tn": "tennessee", "tx": "texas", "ut": "utah", "vt": "vermont", "va": "virginia", "wa": "washington", "wv": "west virginia", "wi": "wisconsin", "wy": "wyoming", "dc": "district of columbia", } US_STATE_ABBR = {v: k.upper() for k, v in _US_STATES.items()} # full name -> 2-letter _US_STATE_LOOKUP = {**_US_STATES, **{v: v for v in _US_STATES.values()}, "washington dc": "district of columbia", "washington d c": "district of columbia"} _IN_STATE_CODES = { "tg": "telangana", "ts": "telangana", "ka": "karnataka", "mh": "maharashtra", "up": "uttar pradesh", "od": "odisha", "wb": "west bengal", "dl": "delhi", "hr": "haryana", "gj": "gujarat", "tn": "tamil nadu", "ap": "andhra pradesh", "mp": "madhya pradesh", "rj": "rajasthan", "pb": "punjab", "kl": "kerala", "br": "bihar", "jh": "jharkhand", "cg": "chhattisgarh", "ct": "chhattisgarh", "uk": "uttarakhand", "ut": "uttarakhand", "hp": "himachal pradesh", "as": "assam", "ga": "goa", "jk": "jammu and kashmir", "ch": "chandigarh", "py": "puducherry", "ar": "arunachal pradesh", "mn": "manipur", "ml": "meghalaya", "mz": "mizoram", "nl": "nagaland", "sk": "sikkim", "tr": "tripura", "la": "ladakh", "ld": "lakshadweep", "an": "andaman and nicobar islands", "dn": "dadra and nagar haveli and daman and diu", "dd": "dadra and nagar haveli and daman and diu", } IN_STATE_ABBR = {"telangana": "TG", "karnataka": "KA", "maharashtra": "MH", "uttar pradesh": "UP", "odisha": "OD", "west bengal": "WB", "delhi": "DL", "haryana": "HR", "gujarat": "GJ", "tamil nadu": "TN", "andhra pradesh": "AP", "madhya pradesh": "MP", "rajasthan": "RJ", "punjab": "PB", "kerala": "KL", "bihar": "BR", "jharkhand": "JH", "chhattisgarh": "CG", "uttarakhand": "UK", "himachal pradesh": "HP", "assam": "AS", "goa": "GA", "jammu and kashmir": "JK", "chandigarh": "CH", "puducherry": "PY"} _IN_STATE_NAMES = sorted(set(_IN_STATE_CODES.values())) _IN_STATE_LEGACY = { "orissa": "odisha", "keralam": "kerala", "pondicherry": "puducherry", "uttaranchal": "uttarakhand", "nct of delhi": "delhi", "new delhi": None, # new delhi is a city, never the state "jammu kashmir": "jammu and kashmir", "j and k": "jammu and kashmir", "tamilnadu": "tamil nadu", "chattisgarh": "chhattisgarh", "west bangal": "west bengal", } # Every Indic-script address part found in S2/S3/T2/T3 (DuckDB scan, 2026-09-25): all state names. _IN_STATE_INDIC_RAW = { "महाराष्ट्र": "maharashtra", "दिल्ली": "delhi", "उत्तर प्रदेश": "uttar pradesh", "ಕರ್ನಾಟಕ": "karnataka", "தமிழ்நாடு": "tamil nadu", "পশ্চিমবঙ্গ": "west bengal", "ગુજરાત": "gujarat", "తెలంగాణ": "telangana", "हरियाणा": "haryana", "राजस्थान": "rajasthan", "കേരളം": "kerala", "बिहार": "bihar", "मध्य प्रदेश": "madhya pradesh", "ఆంధ్రప్రదేశ్": "andhra pradesh", "ਪੰਜਾਬ": "punjab", "ଓଡ଼ିଶା": "odisha", # a few extra spellings that are cheap to cover "ओडिशा": "odisha", "पंजाब": "punjab", "गुजरात": "gujarat", "कर्नाटक": "karnataka", "तमिलनाडु": "tamil nadu", "तेलंगाना": "telangana", "केरल": "kerala", "पश्चिम बंगाल": "west bengal", "झारखंड": "jharkhand", "छत्तीसगढ़": "chhattisgarh", "उत्तराखंड": "uttarakhand", "असम": "assam", "गोवा": "goa", "ആന്ധ്രാപ്രദേശ്": "andhra pradesh", "ఆంధ్ర ప్రదేశ్": "andhra pradesh", } _IN_STATE_LOOKUP = {**_IN_STATE_CODES, **{v: v for v in _IN_STATE_NAMES}, **{k: v for k, v in _IN_STATE_LEGACY.items() if v}, **{" ".join(_prep(k).split()): v for k, v in _IN_STATE_INDIC_RAW.items()}} _FR_REGIONS = [ "auvergne rhone alpes", "bourgogne franche comte", "bretagne", "centre val de loire", "corse", "grand est", "hauts de france", "ile de france", "normandie", "nouvelle aquitaine", "occitanie", "pays de la loire", "provence alpes cote dazur", "guadeloupe", "martinique", "guyane", "la reunion", "mayotte", ] _FR_STATE_LOOKUP = {r: r for r in _FR_REGIONS} _FR_STATE_LOOKUP.update({"paca": "provence alpes cote dazur", "reunion": "la reunion", "pays de loire": "pays de la loire", "idf": "ile de france"}) # Départements: recognised so they are not mistaken for the city; NOT mapped to régions. _FR_DEPARTEMENTS = frozenset(""" ain|aisne|allier|alpes de haute provence|hautes alpes|alpes maritimes|ardeche|ardennes|ariege|aube| aude|aveyron|bouches du rhone|calvados|cantal|charente|charente maritime|cher|correze|corse du sud| haute corse|cote dor|cotes darmor|creuse|dordogne|doubs|drome|eure|eure et loir|finistere|gard| haute garonne|gers|gironde|herault|ille et vilaine|indre|indre et loire|isere|jura|landes| loir et cher|loire|haute loire|loire atlantique|loiret|lot|lot et garonne|lozere|maine et loire| manche|marne|haute marne|mayenne|meurthe et moselle|meuse|morbihan|moselle|nievre|nord|oise|orne| pas de calais|puy de dome|pyrenees atlantiques|hautes pyrenees|pyrenees orientales|bas rhin| haut rhin|rhone|haute saone|saone et loire|sarthe|savoie|haute savoie|seine maritime|seine et marne| yvelines|deux sevres|somme|tarn|tarn et garonne|var|vaucluse|vendee|vienne|haute vienne|vosges|yonne| territoire de belfort|essonne|hauts de seine|seine saint denis|val de marne|val doise """.replace("\n", "").split("|")) # ---------------------------------------------------------------------------------------------- # 8. Addresses: abbreviation maps per country # ---------------------------------------------------------------------------------------------- _ABBR_COMMON = { "rd": "road", "ave": "avenue", "av": "avenue", "avn": "avenue", "ln": "lane", "blvd": "boulevard", "ct": "court", "cir": "circle", "ter": "terrace", "terr": "terrace", "pl": "place", "hwy": "highway", "pkwy": "parkway", "trl": "trail", "sq": "square", "pt": "point", "mt": "mount", "ft": "fort", "n": "north", "s": "south", "e": "east", "w": "west", "ne": "northeast", "nw": "northwest", "se": "southeast", "sw": "southwest", "apt": "apartment", "apts": "apartment", "apartments": "apartment", "appartment": "apartment", "bldg": "building", "fl": "floor", "flr": "floor", "rte": "route", "hts": "heights", "twp": "township", "expy": "expressway", "fwy": "freeway", "ctr": "center", "rm": "room", } _ABBR_INDIA_EXTRA = { "sec": "sector", "ph": "phase", "blk": "block", "opp": "opposite", "nr": "near", "soc": "society", "socy": "society", "ngr": "nagar", "clny": "colony", "extn": "extension", "ext": "extension", "vill": "village", "vil": "village", "dist": "district", "distt": "district", "bhd": "behind", "grd": "ground", "gnd": "ground", "teh": "tehsil", # legacy -> current names "bangalore": "bengaluru", "bombay": "mumbai", "madras": "chennai", "calcutta": "kolkata", "gurgaon": "gurugram", "poona": "pune", "orissa": "odisha", "baroda": "vadodara", "mysore": "mysuru", "mangalore": "mangaluru", "cochin": "kochi", "trivandrum": "thiruvananthapuram", "pondicherry": "puducherry", "keralam": "kerala", "uttaranchal": "uttarakhand", "benares": "varanasi", "allahabad": "prayagraj", "ahmadabad": "ahmedabad", "vizag": "visakhapatnam", "vishakhapatnam": "visakhapatnam", "vishakapatnam": "visakhapatnam", "simla": "shimla", "gulbarga": "kalaburagi", "belgaum": "belagavi", "hubli": "hubballi", } _ABBR_FRANCE = { "r": "rue", "av": "avenue", "ave": "avenue", "avn": "avenue", "bd": "boulevard", "bld": "boulevard", "blvd": "boulevard", "bvd": "boulevard", "pl": "place", "imp": "impasse", "ch": "chemin", "chem": "chemin", "che": "chemin", "all": "allee", "rte": "route", "sq": "square", "qu": "quai", "q": "quai", "crs": "cours", "st": "saint", "ste": "sainte", "fg": "faubourg", "fbg": "faubourg", "res": "residence", "resid": "residence", "appt": "appartement", "apt": "appartement", "bat": "batiment", "pass": "passage", "sent": "sentier", "prom": "promenade", "pte": "porte", "gal": "general", "gen": "general", "mal": "marechal", "pdt": "president", "dr": "docteur", "prof": "professeur", "rpt": "rond point", } _UNIT_WORDS = frozenset("unit apt apartment suite ste bldg building floor fl flr room rm appt " "appartement etage batiment bat".split()) _STREET_TYPES = frozenset( "road street avenue drive lane boulevard court circle terrace place highway parkway trail square " "way loop run pike row walk path alley crossing cove bend marg rue allee impasse chemin route quai " "cours passage sentier promenade".split()) _NULL_PARTS = frozenset(["null", "n a", "na", "none", "nil", "nan", "not available", "unknown"]) _COUNTRY_CFG = { # state_code_first: when several parts look like a state, a 2-letter code beats a full name # (US cities named Washington / Delaware / Indiana ...). India prefers full names because a # stray fragment ('Flo, Or') can look like a code. "us": {"abbr": _ABBR_COMMON, "states": _US_STATE_LOOKUP, "districts": frozenset(), "st_rule": True, "saint_street": True, "drop_after_number": frozenset(), "state_code_first": True, "city_suffix_noise": True}, "india": {"abbr": {**_ABBR_COMMON, **_ABBR_INDIA_EXTRA}, "states": _IN_STATE_LOOKUP, "districts": frozenset(), "st_rule": True, "saint_street": True, "drop_after_number": frozenset(), "state_code_first": False, "city_suffix_noise": False}, "france": {"abbr": _ABBR_FRANCE, "states": _FR_STATE_LOOKUP, "districts": _FR_DEPARTEMENTS, "st_rule": False, "saint_street": False, "drop_after_number": frozenset(["bis", "ter", "quater", "b"]), "state_code_first": False, "city_suffix_noise": False}, } _CFG_DEFAULT = {"abbr": _ABBR_COMMON, "states": {}, "districts": frozenset(), "st_rule": True, "saint_street": False, "drop_after_number": frozenset(), "state_code_first": False, "city_suffix_noise": False} _CITY_TYPOS = frozenset(["cty", "ciy", "citty", "ctiy", "cit", "ctiy"]) _CDP_RE = re.compile(r"^[a-z]?c?cdp$") def _strip_city_noise(toks: tuple) -> tuple: """US vendor noise on the city part: '... CDP', '... CCDP', 'PHOENIXCDP', '... CTIY', and an appended 'City' ('Granite City' vs 'Granite'); trailing city/cdp are dropped on both sides.""" toks = list(toks) if toks and len(toks[-1]) > 5 and toks[-1].endswith("cdp"): toks[-1] = toks[-1][:-3] while len(toks) > 1 and (_CDP_RE.match(toks[-1]) or toks[-1] in _CITY_TYPOS or toks[-1] == "city"): toks.pop() return tuple(toks) # ---------------------------------------------------------------------------------------------- # 9. Address part processing # ---------------------------------------------------------------------------------------------- _PO_BOX_RE = re.compile(r"\b(?:p\s*\.?\s*o\s*\.?\s*box|post\s+box|postbox|pmb)\b\s*[#:.-]?\s*\d*") _HASH_NUM_RE = re.compile(r"#+(?=\s*\d)") _FUSED_NO_RE = re.compile(r"^(no|nos|hno|hn|dno)[-/.:]?(?=\d)") _NUMISH_RE = re.compile(r"^[a-z]{0,2}[-/]?\d") _NUM_SUFFIX_RE = re.compile(r"^(\d+)(bis|ter|quater|b)$") _PREFIX_HEADS = frozenset("h house plot door shop flat office off".split()) _NO_WORDS = frozenset(["no", "nos", "number", "num"]) _FUSED_PREFIX_WORDS = frozenset(["hno", "hn", "dno"]) def _numish(tok: str) -> bool: return bool(_NUMISH_RE.match(tok)) def _strip_zeros(d: str) -> str: return d.lstrip("0") or "0" def _base_part_tokens(part: str, drop_after_number: frozenset) -> list: """Tokens of one comma-part, before abbreviation expansion: '#', 'no', 'h.no', 'plot no'... prefixes removed, ordinals/leading zeros normalised, '1/2' dropped, null dropped.""" s = _PO_BOX_RE.sub(" ", part) s = _HASH_NUM_RE.sub("", s) s = _NULL_TOKEN_RE.sub(" ", s) s = s.replace("&", " and ").replace("#", " ") raw = _dedupe_adjacent(_to_tokens(s)) toks = [] for t in raw: m = _FUSED_NO_RE.match(t) if m: # 'no10' -> 'no', '10'; 'hno-40' -> 'hno', '40' toks.append(m.group(1)) t = t[m.end():].lstrip("-/.:") if t.isdigit(): t = _strip_zeros(t) elif _ORDINAL_RE.match(t): t = _strip_zeros(re.match(r"\d+", t).group()) elif drop_after_number: m2 = _NUM_SUFFIX_RE.match(t) if m2: t = _strip_zeros(m2.group(1)) if t and t != "1/2": toks.append(t) # prefix phrases before a number: 'h no 677', 'plot no 5', 'flat 102', 'no 516', 'hno 40' out = [] i, n = 0, len(toks) while i < n: t = toks[i] nxt = toks[i + 1] if i + 1 < n else "" nxt2 = toks[i + 2] if i + 2 < n else "" if t in _PREFIX_HEADS and nxt in _NO_WORDS and _numish(nxt2): i += 2 continue if t in _PREFIX_HEADS and t not in ("h", "off") and _numish(nxt): i += 1 continue if (t in _NO_WORDS or t in _FUSED_PREFIX_WORDS) and _numish(nxt): i += 1 continue if drop_after_number and t in drop_after_number and out and out[-1][:1].isdigit(): i += 1 continue out.append(t) i += 1 return out def _expand_tokens(toks: list, cfg: dict) -> list: abbr = cfg["abbr"] n = len(toks) out = [] for i, t in enumerate(toks): nxt = toks[i + 1] if i + 1 < n else "" if cfg["st_rule"] and t == "st": # 'st' = saint before a word ('st louis', '5 st andrews rd'), street otherwise t = "saint" if (nxt and nxt[0].isalpha() and nxt not in _UNIT_WORDS) else "street" elif cfg["st_rule"] and t == "dr": t = "drive" if (not nxt or _numish(nxt)) else "dr" elif cfg["st_rule"] and t == "ste": t = "suite" if _numish(nxt) else "ste" elif cfg["saint_street"] and t == "saint" and i == n - 1 and i >= 2 and _numish(toks[0]): t = "street" # vendor noise: '3315 FREMONT SAINT' for 'Fremont Street' else: t = abbr.get(t, t) out.extend(t.split()) return out # part classes P_STREET, P_UNIT, P_OTHER, P_DISTRICT, P_STATE, P_NUMERIC = "street", "unit", "other", "district", "state", "numeric" @lru_cache(maxsize=1 << 18) def _process_part(part: str, ck: str): """-> (tokens tuple, state canonical or '', district or '', is_null, starts_numish, all_numeric, first_is_unit, last_is_street_type)""" cfg = _COUNTRY_CFG.get(ck, _CFG_DEFAULT) base = _base_part_tokens(part, cfg["drop_after_number"]) if not base: return ((), "", "", True, False, False, False, False, 0) joined = " ".join(base) if joined in _NULL_PARTS: return ((), "", "", True, False, False, False, False, 0) state = cfg["states"].get(joined, "") district = joined if (not state and joined in cfg["districts"]) else "" toks = tuple(_expand_tokens(base, cfg)) if state: toks = tuple(state.split()) is_code = len(joined) <= 2 or joined == "district of columbia" state_prio = 2 if is_code == cfg["state_code_first"] else 1 else: state_prio = 0 first = base[0] starts_num = _numish(first) or (len(first) == 1 and first.isalpha() and len(base) > 1 and _numish(base[1])) all_num = all(_HAS_DIGIT_RE.search(t) for t in base) if cfg["city_suffix_noise"] and not state and not starts_num: toks = _strip_city_noise(toks) return (toks, state, district, False, starts_num, all_num, first in _UNIT_WORDS, len(toks) > 1 and (toks[-1] in _STREET_TYPES or toks[0] in _STREET_TYPES), # 'Main St' / 'Rue X' state_prio) def _first_number(tokens) -> str: """Street number from the first number-ish token (a leading single letter may precede it).""" for tok in tokens[:2]: if _numish(tok): m = _DIGITS_RE.search(tok) return _strip_zeros(m.group()) if m else "" return "" _DISTRICT_LIKE_RE = re.compile( r"(?:^| )(?:city|urban|rural|district|dist|distt)$" r"|^(?:north|south|east|west|central)(?: (?:north|south|east|west))? \S") def _pick_city(localities: list) -> str: """Last locality part, skipping parts with digits and district-like parts ('Mumbai City', 'Bangalore Urban', 'South West Delhi') when an alternative exists. On 60k GT pairs this matches the S1 city in 67% of India pairs (plain 'last part': 60%) and 83% of US pairs (unchanged).""" if not localities: return "" cands = [p for p in localities if not _HAS_DIGIT_RE.search(p)] or localities cands = [p for p in cands if not _DISTRICT_LIKE_RE.search(p)] or cands return cands[-1] @dataclass class AddrNorm: tokens: list = field(default_factory=list) # canonical tokens, canonical part order numbers: list = field(default_factory=list) # digit runs, leading zeros stripped, deduped street_number: str = "" city: str = "" state: str = "" # canonical full state / région name postal: str = "" # always '' in this data parts: list = field(default_factory=list) # cleaned comma parts, original order district: str = "" # recognised département (France) or '' localities: list = field(default_factory=list) # all 'other' parts (city candidates) street: str = "" # street part without its leading number def normalize_address(s: str, country: str = "") -> AddrNorm: if not s: return AddrNorm() ck = country_key(country) text = _prep(s) raw_parts = re.split(r"[,;]", text) procs = [] for rp in raw_parts: rp = rp.strip() if not rp: continue pr = _process_part(rp, ck) if pr[3]: # null / empty part continue procs.append(pr) if not procs: return AddrNorm() # state: highest-priority recognised state part, last one on ties; district: last one state_idx = max((i for i, p in enumerate(procs) if p[1]), key=lambda i: (procs[i][8], i), default=-1) district_idx = max((i for i, p in enumerate(procs) if p[2]), default=-1) classes = [] street_found = False for i, p in enumerate(procs): if i == state_idx: c = P_STATE elif i == district_idx: c = P_DISTRICT elif p[5] and street_found: c = P_NUMERIC # e.g. a bare '75182' after the street part elif p[4]: c = P_STREET street_found = True elif p[6]: c = P_UNIT else: c = P_OTHER classes.append(c) if not street_found: # no number: first part starting/ending with a street type ('Kenforest Drive', 'Rue Darras') for i, p in enumerate(procs): if classes[i] == P_OTHER and p[7]: classes[i] = P_STREET break order = {P_STREET: 0, P_UNIT: 1, P_NUMERIC: 2, P_OTHER: 3, P_DISTRICT: 4, P_STATE: 5} idx_sorted = sorted(range(len(procs)), key=lambda i: (order[classes[i]], i)) tokens = [t for i in idx_sorted for t in procs[i][0]] numbers = [] seen = set() for i in idx_sorted: if classes[i] == P_STATE: continue for t in procs[i][0]: if _HAS_DIGIT_RE.search(t): for d in _DIGITS_RE.findall(t): d = _strip_zeros(d) if d not in seen: seen.add(d) numbers.append(d) street_number, street = "", "" street_parts = [i for i in range(len(procs)) if classes[i] == P_STREET] if street_parts: st_toks = procs[street_parts[0]][0] if procs[street_parts[0]][4]: street_number = _first_number(st_toks) street = " ".join(t for t in st_toks if not _HAS_DIGIT_RE.search(t) and not (len(t) == 1 and t.isalpha())) localities = [" ".join(procs[i][0]) for i in range(len(procs)) if classes[i] == P_OTHER] city = _pick_city(localities) return AddrNorm( tokens=tokens, numbers=numbers, street_number=street_number, city=city, state=procs[state_idx][1] if state_idx >= 0 else "", postal="", parts=[" ".join(p[0]) for p in procs], district=procs[district_idx][2] if district_idx >= 0 else "", localities=localities, street=street, ) # ---------------------------------------------------------------------------------------------- # 10. Record-level helpers and blocking keys # ---------------------------------------------------------------------------------------------- _GENERIC_NAME_WORDS = frozenset( "and of the india care associates group center centre partners services service health clinic " "company medical dental family medicine consulting solutions systems international global " "enterprises trading industries holdings ventures club ecole maison association amicale comite " "union federation societe france de la le les du des et private limited llc inc ltd pvt".split()) def _rarest_token(tokens, token_df=None) -> str: cands = [t for t in tokens if len(t) >= 3 and not t.isdigit()] if not cands: return "" if token_df is not None: return min(cands, key=lambda t: (token_df.get(t, 0), -len(t))) specific = [t for t in cands if t not in _GENERIC_NAME_WORDS] or cands return max(specific, key=len) def blocking_keys(name: NameNorm, addr: AddrNorm = None, country: str = "", token_df=None) -> list: """Cheap blocking keys (strings, prefixed by country key): ns = spaceless name core (plus spaceless alt names), f2 = first two core tokens, cs = (city, street_number), cr = (city, rarest-looking name token; lowest df if token_df given).""" ck = country_key(country) keys = [] if name.spaceless: keys.append(f"{ck}|ns|{name.spaceless}") for alt in name.alt_names: keys.append(f"{ck}|ns|{alt.replace(' ', '')}") if len(name.tokens) >= 2: keys.append(f"{ck}|f2|{name.tokens[0]} {name.tokens[1]}") if addr is not None and addr.city: if addr.street_number: keys.append(f"{ck}|cs|{addr.city}|{addr.street_number}") rare = _rarest_token(name.tokens, token_df) if rare: keys.append(f"{ck}|cr|{addr.city}|{rare}") return list(dict.fromkeys(keys)) def normalize_record(name: str, address: str, country: str) -> dict: """Flat dict: name_* and addr_* fields plus 'country' key and 'blocking_keys'.""" nn = normalize_name(name, country) an = normalize_address(address, country) rec = {"country": country_key(country)} rec.update({f"name_{k}": v for k, v in vars(nn).items()}) rec.update({f"addr_{k}": v for k, v in vars(an).items()}) rec["blocking_keys"] = blocking_keys(nn, an, country) return rec def blocking_normalizer(df): """Adapter for ``src.blocking --normalizer src.normalize:blocking_normalizer``: takes a polars DataFrame (entity_id, business_name, business_address, country) and adds name_n (core), name_ns (spaceless core) and addr_n (canonical address tokens). polars is imported lazily so this module itself stays stdlib-only.""" import polars as pl # noqa: WPS433 (optional dependency, only for this adapter) names = df["business_name"].to_list() addrs = df["business_address"].to_list() ctry = df["country"].to_list() name_n, name_ns, addr_n = [], [], [] for n, a, c in zip(names, addrs, ctry): nn = normalize_name(n or "", c or "") an = normalize_address(a or "", c or "") name_n.append(nn.core) name_ns.append(nn.spaceless) addr_n.append(" ".join(an.tokens)) return df.with_columns(pl.Series("name_n", name_n, dtype=pl.Utf8), pl.Series("name_ns", name_ns, dtype=pl.Utf8), pl.Series("addr_n", addr_n, dtype=pl.Utf8))