| """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", |
| ] |
|
|
| |
| |
| |
| |
| _MOJIBAKE_RE = re.compile("[\u00c2\u00e2]\u0080([\u0080-\u00bf])") |
| _MOJIBAKE_THIRD = { |
| 0x90: "-", 0x91: "-", 0x92: "-", 0x93: "-", 0x94: "-", 0x95: "-", |
| 0x98: "'", 0x99: "'", 0x9a: "'", 0x9b: "'", |
| 0x9c: '"', 0x9d: '"', 0x9e: '"', |
| } |
| |
| _CP1252_MOJIBAKE = {"\u00e2\u20ac\u2122": "'", "\u00e2\u20ac\u02dc": "'", "\u00e2\u20ac\u201c": "-", |
| "\u00e2\u20ac\u201d": "-", "\u00e2\u20ac\u0153": '"'} |
|
|
| _CHAR_FIX = { |
| |
| **{cp: None for cp in range(0x80, 0xA0)}, |
| 0x80: " ", 0x82: ",", 0x84: '"', 0x85: " ", 0x8B: " ", 0x91: "'", 0x92: "'", 0x93: '"', |
| 0x94: '"', 0x95: " ", 0x96: "-", 0x97: "-", 0x9B: " ", |
| |
| 0x200B: None, 0x200C: None, 0x200D: None, 0x2060: None, 0xFEFF: None, 0x00AD: None, |
| |
| 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", |
| } |
|
|
|
|
| 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) |
|
|
|
|
| |
| |
| |
| _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) |
|
|
|
|
| def _prep(s: str) -> str: |
| """fix_encoding + lowercase + accent fold.""" |
| return fold_accents(fix_encoding(s).lower()) |
|
|
|
|
| |
| |
| |
| 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"(?<![a-z0-9])((?:[a-z]\.){1,}[a-z])\.?(?![a-z0-9])") |
| _APOS_RE = re.compile(r"['\"]") |
| _ELISION_SPACE_RE = re.compile(r"(?<![a-z])([cdjlmnst]|qu)'\s+(?=[a-z])") |
| _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) |
|
|
|
|
| |
| |
| |
| _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)) |
|
|
|
|
| |
| |
| |
| _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) |
|
|
|
|
| |
| |
| |
| STRONG, EDGE, SUFFIX, PAIR = "strong", "edge", "suffix", "pair" |
| |
| |
| |
| _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), |
| } |
| |
| _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_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+") |
| _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") |
| _CODE_TOKEN_RE = re.compile(r"^\d+[a-z]$|^[a-z]\d+$") |
| _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] |
| |
| 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] |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| 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: |
| 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() |
| |
| 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": |
| toks = toks[2:] |
| core, legal = _extract_legal(toks, table) |
| return core, legal, False, toks |
|
|
|
|
| @dataclass |
| class NameNorm: |
| core: str = "" |
| legal: str = "" |
| tokens: list = field(default_factory=list) |
| spaceless: str = "" |
| alt_names: list = field(default_factory=list) |
| is_domain_form: bool = False |
| has_indic_script: bool = False |
| full: str = "" |
|
|
|
|
| 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) |
|
|
|
|
| |
| |
| |
| _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()} |
| _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, |
| "jammu kashmir": "jammu and kashmir", "j and k": "jammu and kashmir", "tamilnadu": "tamil nadu", |
| "chattisgarh": "chhattisgarh", "west bangal": "west bengal", |
| } |
| |
| _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", |
| |
| "ओडिशा": "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"}) |
| |
| _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("|")) |
|
|
| |
| |
| |
| _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", |
| |
| "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 = { |
| |
| |
| |
| "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) |
|
|
| |
| |
| |
| _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: |
| 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) |
| |
| 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": |
| |
| 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" |
| else: |
| t = abbr.get(t, t) |
| out.extend(t.split()) |
| return out |
|
|
|
|
| |
| 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), |
| 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) |
| numbers: list = field(default_factory=list) |
| street_number: str = "" |
| city: str = "" |
| state: str = "" |
| postal: str = "" |
| parts: list = field(default_factory=list) |
| district: str = "" |
| localities: list = field(default_factory=list) |
| street: str = "" |
|
|
|
|
| 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]: |
| continue |
| procs.append(pr) |
| if not procs: |
| return AddrNorm() |
|
|
| |
| 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 |
| 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: |
| 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, |
| ) |
|
|
|
|
| |
| |
| |
| _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 |
|
|
| 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)) |
|
|
