es-normalizer-py 0.2.4__py3-none-any.whl

es_normalizer/__init__.py

@@ -0,0 +1,243 @@
+"""
+Contact data normalization adapted from the Empreinte Sociométrique's normalizers, the Python port of es-normalizer
+
+Every normalizer takes a string and returns the normalized string, or `None` when nothing usable is left.
+"""
+
+import re
+import unicodedata
+from typing import Callable, Optional
+
+from .dictionary import Dictionary, address_dictionary, first_name_dictionary, get_set, title_dictionary
+
+Normalizer = Callable[[str], Optional[str]]
+
+
+def normalize(data: str, normalizer: Normalizer) -> Optional[str]:
+    return normalizer(data)
+
+
+def uniformize(data: str) -> Optional[str]:
+    """
+    Upper-cases the passed string without its accents, any run of other characters than letters, digits and dashes becoming a single space
+    """
+    normalized = "".join(c for c in unicodedata.normalize("NFD", data.strip().lower()) if not "̀" <= c <= "ͯ")
+    if normalized == "":
+        return None
+    uniformized = normalized.replace("ß", "ss").replace("ø", "o")
+    uniformized = re.sub(r"[^a-zA-Z0-9-]+", "-", uniformized)
+    uniformized = re.sub(r"-+", "-", uniformized).replace("-", " ").strip().upper()
+    return uniformized or None
+
+
+def Any(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer to use for any kind of data when no specific normalizer exists
+    """
+    return uniformize(data)
+
+
+def AddressLine(transform_title: bool = False) -> Normalizer:  # noqa: N802
+    """
+    Normalizer of an address line, eg. `8, rue Henner` becomes `8 RUE HENNER`; with `transform_title`, a French address
+    line 1 gets its title coded, eg. `Monsieur Cyril Dever` becomes `1 CYRIL DEVER`
+    """
+
+    def normalizer(data: str) -> Optional[str]:
+        uniformized = uniformize(data)
+        if uniformized is None:
+            return None
+        return (title_dictionary if transform_title else address_dictionary).translate_text(uniformized)
+
+    return normalizer
+
+
+_AL6 = re.compile(r"^((0[1-9]|[1-8][0-9]|9[0-5]|2[AB]|97[1-8]|98[46-9])([0-9]{3}))(.*)$")
+
+
+def AddressLine6(use_department_france: bool = True) -> Normalizer:  # noqa: N802
+    """
+    Normalizer of the French address line 6, the département inserted between the postal code and the town, eg. `75009 75 PARIS`
+    """
+
+    def normalizer(data: str) -> Optional[str]:
+        line = AddressLine(False)(data)
+        if line is None:
+            return None
+        matches = _AL6.match(line)
+        if not matches or not matches.group(1):
+            return None
+        cp, dpt, city = matches.group(1), matches.group(2), matches.group(4)
+        if city.strip().startswith(dpt):
+            parts = [cp, city.strip()] if use_department_france else [cp, city.replace(dpt, "", 1).strip()]
+        else:
+            parts = [cp, dpt, city.strip()] if use_department_france else [cp, city.strip()]
+        return " ".join(parts).strip()
+
+    return normalizer
+
+
+def City(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a town's name, its CEDEX mention removed
+    """
+    uniformized = uniformize(data)
+    if uniformized is None:
+        return None
+    found = re.sub(r"CDX(\s+[0-9]+)*", "", address_dictionary.translate_text(uniformized), count=1)
+    return re.sub(r"\s+", " ", found).strip()
+
+
+_CP = re.compile(r"^((0[1-9][0-9]|[1-8][0-9]{2})|(9[0-5][0-9])|(2[AB][0-9])|(97[1-6]))[0-9]{2}$")
+_CORSE = re.compile(r"^2[AB][0-9]{3}$")
+
+
+def CodePostalFrance(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a French postal code, a Corsican one written with its département (`2A165`) becoming `20165`
+    """
+    uniformized = uniformize(data)
+    if uniformized is None:
+        return None
+    words = re.split(r"\s", uniformized)
+    candidate = words[0] if len(words) > 1 else uniformized
+    if not _CP.search(candidate):
+        return None
+    return re.sub(r"[AB]", "0", candidate, count=1) if _CORSE.search(candidate) else candidate
+
+
+_DPT = re.compile(r"^(0[1-9]|[1-8][0-9]|9[0-5]|2[AB]|97[1-8]|98[46-9])([0-9]*)$")
+
+
+def DepartementFrance(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer extracting the French département out of a postal code, eg. `2A` out of `20167`
+    """
+    uniformized = uniformize(data)
+    if not uniformized:
+        return None
+    matches = _DPT.match(uniformized)
+    if not matches or not matches.group(1):
+        return None
+    dpt = matches.group(1)
+    if dpt != "20":
+        return dpt
+    cp = CodePostalFrance(data)
+    if cp is None:
+        return None
+    return "2A" if 19999 < int(cp) < 20200 else "2B"
+
+
+_EMAIL = re.compile(
+    r"^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f]))"
+    r"@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[a-z]{2,}[a-z0-9-]*|([a-z][a-z0-9-]+))|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.?){4})$"
+)
+
+
+def Email(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer validating an e-mail address and lower-casing it
+    """
+    processed = data.strip().lower()
+    if len(processed) > 255 or not _EMAIL.search(processed):
+        return None
+    return processed
+
+
+def FirstName(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a first name, through a French dictionary of first names, eg. `J Louis` becomes `JEAN LOUIS`
+    """
+    uniformized = uniformize(data)
+    return None if uniformized is None else first_name_dictionary.translate_word(uniformized)
+
+
+_MOBILE = re.compile(r"^(((00)?(33))|0)?([0]?)([0-9])([0-9]{2})([0-9]{3})([0-9]{3})$")
+
+
+def Mobile(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a French mobile phone number in the international format, eg. `+33 (0) 623 456 789`
+    """
+    uniformized = uniformize(data)
+    if uniformized is None:
+        return None
+    m = _MOBILE.match(re.sub(r"\s", "", uniformized))
+    if not m:
+        return None
+    if not (m.group(7) and m.group(8) and m.group(9)) or (m.group(7) + m.group(8) + m.group(9)).endswith("00000000"):
+        return None
+    if not ((m.group(6) and m.group(6) == "6") or m.group(6) == "7"):
+        return None
+    international = f"+{m.group(4)}" if m.group(4) else "+33"
+    prefix = f"({m.group(5)})" if m.group(5) else "(0)"
+    return " ".join([international, prefix, m.group(6) + m.group(7), m.group(8), m.group(9)])
+
+
+_PHONE = re.compile(r"^(((00)?(33)|0?(262)|0?(590)|0?(594)|0?(596))([^1-9]*)|0)?([^0-9]*)([0-9]{3})([0-9]{3})([0-9]{3})$")
+
+
+def PhoneNumber(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a French phone or fax number in the international format, eg. `+33 (0) 123 456 789`
+    """
+    uniformized = uniformize(data)
+    if uniformized is None:
+        return None
+    m = _PHONE.match(re.sub(r"\s", "", uniformized))
+    if not m:
+        return None
+    if not (m.group(11) and m.group(12) and m.group(13)) or (m.group(11) + m.group(12) + m.group(13)).endswith("00000000"):
+        return None
+    international = f"+{m.group(4)}" if m.group(4) else "+33"
+    prefix = f"({m.group(9)})" if m.group(9) else "(0)"
+    return " ".join([international, prefix, m.group(11), m.group(12), m.group(13)])
+
+
+_STREET_NUMBER = re.compile(r"^([0-9]*)\s*(.*)$")
+
+
+def StreetNumber(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a street number, eg. `1bis` or `1 bis` becomes `1B`
+    """
+    m = _STREET_NUMBER.match(data.strip())
+    if not m:
+        return None
+    if not m.group(2):
+        return m.group(1)
+    uniformized = uniformize(m.group(2))
+    if uniformized is None:
+        return None
+    return m.group(1) + address_dictionary.translate_text(uniformized).split(" ")[0]
+
+
+_CODE_F, _CODE_M, _CODE_U = "2", "1", "0"
+
+
+def Title(data: str) -> Optional[str]:  # noqa: N802
+    """
+    Normalizer of a title into a code: 1 for gentlemen, 2 for ladies, 0 when undefined or unknown
+    """
+    translated = uniformize(data)
+    if translated is None:
+        return None
+    if translated in ("H", "M"):
+        return _CODE_M
+    if translated == "F":
+        return _CODE_F
+    if translated == "U":
+        return _CODE_U
+    found = re.findall(r"[0-9]+", title_dictionary.translate_text(translated))
+    if not found:
+        return None
+    return found[0] if len(found) == 1 else _CODE_U
+
+
+from .date_of_birth import FRENCH_DATE, ISO_DATE, DateOfBirth, Milliseconds, Timestamp  # noqa: E402
+
+__all__ = [
+    "Dictionary", "get_set", "normalize", "uniformize", "Any", "AddressLine", "AddressLine6", "City", "CodePostalFrance",
+    "DateOfBirth", "DepartementFrance", "Email", "FirstName", "Mobile", "PhoneNumber", "StreetNumber", "Title",
+    "FRENCH_DATE", "ISO_DATE", "Timestamp", "Milliseconds",
+]

es_normalizer/date_of_birth.py

@@ -0,0 +1,128 @@
+"""
+The date of birth normalizer, which reads and writes dates the way moment.js does in its forgiving mode, as es-normalizer relies on it
+"""
+
+import calendar
+import re
+from datetime import date, datetime
+from typing import Callable, Optional
+
+FRENCH_DATE = "DD/MM/YYYY"
+ISO_DATE = "YYYYMMDD"
+Timestamp = "timestamp"
+Milliseconds = "timestamp_millis"
+
+_SEPARATORS = re.compile(r"[-:/\s]+")
+_TOKENS = re.compile(r"YYYY|YY|MMMM|MMM|MM|M|DD|D|HH|H|SS|S")
+_MONTHS = [calendar.month_name[i] for i in range(1, 13)]
+_SHORT_MONTHS = [calendar.month_abbr[i] for i in range(1, 13)]
+_MONTH_NAME = re.compile("|".join(_MONTHS + _SHORT_MONTHS), re.IGNORECASE)
+# What each token matches, searched anywhere in what is left of the input
+_PARSE = {
+    "YYYY": re.compile(r"\d{1,4}"),
+    "YY": re.compile(r"\d\d?"),
+    "MMMM": _MONTH_NAME,
+    "MMM": _MONTH_NAME,
+    "MM": re.compile(r"\d\d?"),
+    "M": re.compile(r"\d\d?"),
+    "DD": re.compile(r"\d\d?"),
+    "D": re.compile(r"\d\d?"),
+    "HH": re.compile(r"\d\d?"),
+    "H": re.compile(r"\d\d?"),
+    "SS": re.compile(r"\d+"),
+    "S": re.compile(r"\d+"),
+}
+
+
+def _month_of(name: str) -> int:
+    name = name.lower()
+    for i, (full, short) in enumerate(zip(_MONTHS, _SHORT_MONTHS), start=1):
+        if name == full.lower() or name == short.lower():
+            return i
+    return 0
+
+
+def _two_digit_year(value: str) -> int:
+    return int(value) + (1900 if int(value) > 68 else 2000)
+
+
+def _parse(data: str, fmt: str) -> Optional[date]:
+    year, month, day = date.today().year, 1, 1
+    rest = data
+    parsed = False
+    for token in _TOKENS.findall(fmt):
+        found = _PARSE[token].search(rest)
+        if not found:
+            continue
+        rest = rest[found.end():]
+        parsed = True
+        value = found.group(0)
+        if token == "YYYY":
+            # As moment.js: a year of two digits is read as one of `YY`
+            year = _two_digit_year(value) if len(value) == 2 else int(value)
+        elif token == "YY":
+            year = _two_digit_year(value)
+        elif token in ("MMMM", "MMM"):
+            month = _month_of(value)
+        elif token in ("MM", "M"):
+            month = int(value)
+        elif token in ("DD", "D"):
+            day = int(value)
+    if not parsed:
+        return None
+    try:
+        return date(year, month, day)
+    except ValueError:
+        return None
+
+
+def _format(d: date, fmt: str) -> str:
+    def token(m: re.Match) -> str:
+        t = m.group(0)
+        return {
+            "YYYY": f"{d.year:04d}",
+            "YY": f"{d.year % 100:02d}",
+            "MMMM": _MONTHS[d.month - 1],
+            "MMM": _SHORT_MONTHS[d.month - 1],
+            "MM": f"{d.month:02d}",
+            "M": str(d.month),
+            "DD": f"{d.day:02d}",
+            "D": str(d.day),
+            "HH": "00",
+            "H": "0",
+            "SS": "00",
+            "S": "0",
+        }[t]
+
+    return _TOKENS.sub(token, fmt)
+
+
+def _leading_int(data: str) -> Optional[int]:
+    # As JavaScript's `parseInt`: the leading digits, sign included
+    found = re.match(r"\s*([+-]?\d+)", data)
+    return int(found.group(1)) if found else None
+
+
+def DateOfBirth(input_format: str = None, output_format: str = None) -> Callable[[str], Optional[str]]:  # noqa: N802
+    """
+    Normalizer of a date of birth, read in the input format (ISO by default) and written in the output one (French by
+    default), eg. `24/04/2010` read as `DD/MM/YYYY` and written as `ISO_DATE` becomes `20100424`
+    """
+    inp = ISO_DATE if not input_format else input_format
+    out = FRENCH_DATE if not output_format else output_format
+
+    def normalizer(data: str) -> Optional[str]:
+        if inp.lower() in (Timestamp, Milliseconds):
+            value = _leading_int(data)
+            if value is None:
+                return None
+            d = datetime.fromtimestamp(value if inp.lower() == Timestamp else value / 1000).date()
+        else:
+            d = _parse(data, _SEPARATORS.sub("-", inp).upper())
+        if d is None:
+            return None
+        written = _format(d, _SEPARATORS.sub("-", out).upper())
+        separator = _SEPARATORS.search(out)
+        return written if separator is None else written.replace("-", separator.group(0))
+
+    return normalizer

es_normalizer/dictionary/__init__.py

@@ -0,0 +1,48 @@
+from .address import ADDRESS
+from .firstname import FIRST_NAME
+from .title import TITLE
+
+
+class Dictionary:
+    """
+    Translates words through a set of `word -> translation` pairs, an empty translation dropping the word; a key of several words translates them together, the longest first
+    """
+
+    def __init__(self, data_set: dict):
+        self.set = data_set
+        self.phrases = sorted((tuple(key.split(" ")) for key in data_set if " " in key), key=len, reverse=True)
+
+    def translate_text(self, text: str) -> str:
+        words = text.split(" ")
+        translated = []
+        i = 0
+        while i < len(words):
+            phrase = next((p for p in self.phrases if tuple(words[i : i + len(p)]) == p), None)
+            if phrase is not None and self.set[" ".join(phrase)] is not None:
+                translated.append(self.set[" ".join(phrase)])
+                i += len(phrase)
+                continue
+            translated.append(self.translate_word(words[i]))
+            i += 1
+        return " ".join(word for word in translated if word != "")
+
+    def translate_word(self, word: str) -> str:
+        translation = self.set.get(word)
+        return word if translation is None else translation
+
+
+def get_set(data: str) -> dict:
+    """
+    Reads a dictionary written one `word<TAB>translation` pair per line; a line without a tab translates nothing
+    """
+    data_set = {}
+    for line in data.split("\n"):
+        # As JavaScript's `split('\t', 2)`: anything after a second tab is dropped
+        parts = line.split("\t")[:2]
+        data_set[parts[0]] = parts[1] if len(parts) > 1 else None
+    return data_set
+
+
+address_dictionary = Dictionary(get_set(ADDRESS))
+first_name_dictionary = Dictionary(get_set(FIRST_NAME))
+title_dictionary = Dictionary(get_set(TITLE))

es_normalizer/dictionary/address.py

@@ -0,0 +1,110 @@
+ADDRESS = """ALLEE	ALL
+ALLEES	ALL
+AVENUE	AV
+AVENU	AV
+AVE	AV
+AVN	AV
+BOUL	BD
+BOULEV	BD
+BOULEVARD	BD
+BOULEVAR	BD
+BLVD	BD
+BVD	BD
+BLD	BD
+BRD	BD
+CHE	CH
+CHEMIN	CH
+CHM	CH
+COUR	CRS
+COURS	CRS
+DOMAINE	DOM
+DOMAINES	DOM
+ESCALIER	ESC
+ESPLANADE	ESP
+IMPAS	IMP
+IMPASSE	IMP
+IMPASSES	IMP
+LOTISSEMENT	LOT
+LOTISSEMENTS	LOT
+PASSAGE	PASS
+PCE	PL
+PLACE	PL
+PLC	PL
+PORTE	PTE
+PRTE	PTE
+QUAI	QU
+QUAIS	QU
+RESIDENCE	RES
+RESIDENCES	RES
+ROND POINT	RPT
+RONDPOINT	RPT
+RDPT	RPT
+ROUTE	RTE
+ROUTES	RTE
+R	RUE
+RU	RUE
+RUELLE	RLE
+RUELLES	RLE
+RUES	RUE
+SENT	SENTE
+SENTE	SENTE
+SQUA	SQ
+SQUARE	SQ
+VILLA	VLA
+VILLAS	VLA
+VOIE	VOI
+VOIES	VOI
+BIS	B
+BI	B
+BS	B
+TER	T
+TR	T
+QUATER	Q
+QUAT	Q
+QUINQUIES	C
+QUI	C
+SEXIES	S
+SEX	S
+SEPTIES	Z
+SEP	Z
+OCTIES	O
+OCT	O
+NOVIES	N
+NOV	N
+DECIES	D
+DEC	D
+DU	
+DE	
+DES	
+D	
+LE	
+LA	
+LES	
+L	
+ET	
+GENERAL	GAL
+GNRL	GAL
+GL	GAL
+PRESIDENT	PDT
+MARECHAL	MAL
+DOCTEUR	DR
+GRANDE	GDE
+GRAND	GD
+PETITE	PTE
+PETIT	PT
+SAINT	ST
+SAINTE	STE
+CEDEX	CDX
+CEDX	CDX
+CDEX	CDX
+CX	CDX
+FAUBOURG	FBG
+CENTRE COMMERCIAL	CCAL
+CENTRE CIAL	CCAL
+CENTRE CCIAL	CCAL
+CTRE COMMERCIAL	CCAL
+CTRE CIAL	CCAL
+CTRE CCIAL	CCAL
+C COMMERCIAL	CCAL
+C CIAL	CCAL
+CCIAL	CCAL"""

es_normalizer/dictionary/firstname.py

@@ -0,0 +1,229 @@
+FIRST_NAME = """J ROGER	JEAN ROGER
+J ARNAUD	JEAN ARNAUD
+J AUGUSTE	JEAN AUGUSTE
+J SYLVESTRE	JEAN SYLVESTRE
+J SULLY	JEAN SULLY
+J GUY	JEAN GUY
+J MAXIME	JEAN MAXIME
+J RENE	JEAN RENE
+J MARTIN	JEAN MARTIN
+J ARMEL	JEAN ARMEL
+J ADRIEN	JEAN ADRIEN
+J MATTHIEU	JEAN MATTHIEU
+J GAEL	JEAN GAEL
+J RAOUL	JEAN RAOUL
+J STEPHAN	JEAN STEPHAN
+J VALERE	JEAN VALERE
+J NORBERT	JEAN NORBERT
+J YANNICK	JEAN YANNICK
+J FREDERIC	JEAN FREDERIC
+J EUDE	JEAN EUDE
+J AURELIEN	JEAN AURELIEN
+J YVON	JEAN YVON
+J LUCAS	JEAN LUCAS
+J THIERRY	JEAN THIERRY
+J MAX	JEAN MAX
+J LUDOVIC	JEAN LUDOVIC
+J ANDRE	JEAN ANDRE
+J ROCH	JEAN ROCH
+J ELIE	JEAN ELIE
+J ELOI	JEAN ELOI
+J SERGE	JEAN SERGE
+J PHILIPPE	JEAN PHILIPPE
+J DANY	JEAN DANY
+J MARIN	JEAN MARIN
+J YANN	JEAN YANN
+J HUGUES	JEAN HUGUES
+J CONSTANT	JEAN CONSTANT
+J JACK	JEAN JACK
+J ALIX	JEAN ALIX
+J MARK	JEAN MARK
+J CARL	JEAN CARL
+J GREGOIRE	JEAN GREGOIRE
+J EUGENE	JEAN EUGENE
+J BRIEUC	JEAN BRIEUC
+J DENYS	JEAN DENYS
+J EMILE	JEAN EMILE
+J NICOLAS	JEAN NICOLAS
+J FRANCOIS	JEAN FRANCOIS
+J RICHARD	JEAN RICHARD
+J THEOPHANE	JEAN THEOPHANE
+J DAVY	JEAN DAVY
+J BENOIT	JEAN BENOIT
+J PAUL	JEAN PAUL
+J RODOLPHE	JEAN RODOLPHE
+J QUENTIN	JEAN QUENTIN
+J MICKAEL	JEAN MICKAEL
+J BRIAC	JEAN BRIAC
+J DAVID	JEAN DAVID
+J MARC	JEAN MARC
+J VIANNEY	JEAN VIANNEY
+J AIME	JEAN AIME
+J DOMINIQUE	JEAN DOMINIQUE
+J EDDY	JEAN EDDY
+J BRICE	JEAN BRICE
+J FABIEN	JEAN FABIEN
+J CLAUDE	JEAN CLAUDE
+J WILFRIED	JEAN WILFRIED
+J DAMIEN	JEAN DAMIEN
+J WILLIAM	JEAN WILLIAM
+J EDOUARD	JEAN EDOUARD
+J RUDY	JEAN RUDY
+J LEON	JEAN LEON
+J NOEL	JEAN NOEL
+J BATISTE	JEAN BATISTE
+J REMY	JEAN REMY
+J OLIVIER	JEAN OLIVIER
+J BENJAMIN	JEAN BENJAMIN
+J MARY	JEAN MARY
+J BERNARD	JEAN BERNARD
+J CHARLES	JEAN CHARLES
+J CHRISTOPHER	JEAN CHRISTOPHER
+J MATHIS	JEAN MATHIS
+J MARCEL	JEAN MARCEL
+J CHRISTIAN	JEAN CHRISTIAN
+J STANISLAS	JEAN STANISLAS
+J ERNEST	JEAN ERNEST
+J BASTIEN	JEAN BASTIEN
+J FREDDY	JEAN FREDDY
+J ERICK	JEAN ERICK
+J VITAL	JEAN VITAL
+J FRANCO	JEAN FRANCO
+J ROMAIN	JEAN ROMAIN
+J RENAUD	JEAN RENAUD
+J PATRICE	JEAN PATRICE
+J PATRICK	JEAN PATRICK
+J EMMANUEL	JEAN EMMANUEL
+J STEPHANE	JEAN STEPHANE
+J XAVIER	JEAN XAVIER
+J BRUNO	JEAN BRUNO
+J MOISE	JEAN MOISE
+J LUC	JEAN LUC
+J VICTOR	JEAN VICTOR
+J VIVIEN	JEAN VIVIEN
+J CYRILLE	JEAN CYRILLE
+J KARL	JEAN KARL
+J JOSEPH	JEAN JOSEPH
+J MICHAEL	JEAN MICHAEL
+J AUGUSTIN	JEAN AUGUSTIN
+J THOMAS	JEAN THOMAS
+J LOUIS	JEAN LOUIS
+J ALEXANDRE	JEAN ALEXANDRE
+J SYLVAIN	JEAN SYLVAIN
+J LOIC	JEAN LOIC
+J PHILIP	JEAN PHILIP
+J FERNAND	JEAN FERNAND
+J MALO	JEAN MALO
+J ALBERT	JEAN ALBERT
+J FLORENT	JEAN FLORENT
+J POL	JEAN POL
+J ARMAND	JEAN ARMAND
+J GERARD	JEAN GERARD
+J AXEL	JEAN AXEL
+J FABRICE	JEAN FABRICE
+J ARTHUR	JEAN ARTHUR
+J LUCIEN	JEAN LUCIEN
+J LAURENT	JEAN LAURENT
+J JUNIOR	JEAN JUNIOR
+J LUCE	JEAN LUCE
+J CLEMENT	JEAN CLEMENT
+J COME	JEAN COME
+J VALERY	JEAN VALERY
+J HERVE	JEAN HERVE
+J BART	JEAN BART
+J FELIX	JEAN FELIX
+J REMI	JEAN REMI
+J CYRIL	JEAN CYRIL
+J MATHIAS	JEAN MATHIAS
+J BLAISE	JEAN BLAISE
+J MARIE	JEAN MARIE
+J CAMILLE	JEAN CAMILLE
+J LOU	JEAN LOU
+J DANIEL	JEAN DANIEL
+J JACQUES	JEAN JACQUES
+J FLORIAN	JEAN FLORIAN
+J GUILLAUME	JEAN GUILLAUME
+J SEBASTIEN	JEAN SEBASTIEN
+J HENRI	JEAN HENRI
+J CYPRIEN	JEAN CYPRIEN
+J LEO	JEAN LEO
+J ERIC	JEAN ERIC
+J SAMUEL	JEAN SAMUEL
+J GILLES	JEAN GILLES
+J ETIENNE	JEAN ETIENNE
+J VINCENT	JEAN VINCENT
+J ROLAND	JEAN ROLAND
+J EUDES	JEAN EUDES
+J JOEL	JEAN JOEL
+J GIL	JEAN GIL
+J TRISTAN	JEAN TRISTAN
+J ALEXIS	JEAN ALEXIS
+J CHRISTOPHE	JEAN CHRISTOPHE
+J BOSCO	JEAN BOSCO
+J DESIRE	JEAN DESIRE
+J LOUP	JEAN LOUP
+J PIERROT	JEAN PIERROT
+J GREGORY	JEAN GREGORY
+J KEVIN	JEAN KEVIN
+J HUGO	JEAN HUGO
+J YAN	JEAN YAN
+J BAPTISTE	JEAN BAPTISTE
+J JULES	JEAN JULES
+J ROBERT	JEAN ROBERT
+J GUILHEM	JEAN GUILHEM
+J JULIEN	JEAN JULIEN
+J MATHIEU	JEAN MATHIEU
+J ALEX	JEAN ALEX
+J PIERRE	JEAN PIERRE
+J GILBERT	JEAN GILBERT
+J GEORGES	JEAN GEORGES
+J HENRY	JEAN HENRY
+J WILFRID	JEAN WILFRID
+J LIN	JEAN LIN
+J BARTHELEMY	JEAN BARTHELEMY
+J ANTOINE	JEAN ANTOINE
+J EDMOND	JEAN EDMOND
+J ALAIN	JEAN ALAIN
+J DENIS	JEAN DENIS
+J GERALD	JEAN GERALD
+J WILSON	JEAN WILSON
+J LIONEL	JEAN LIONEL
+J RAPHAEL	JEAN RAPHAEL
+J ROBIN	JEAN ROBIN
+J YVES	JEAN YVES
+J PASCAL	JEAN PASCAL
+J FRANCIS	JEAN FRANCIS
+J TEDDY	JEAN TEDDY
+J AYMERIC	JEAN AYMERIC
+J GUSTAVE	JEAN GUSTAVE
+J MAEL	JEAN MAEL
+J ALFRED	JEAN ALFRED
+J MARIUS	JEAN MARIUS
+J REGIS	JEAN REGIS
+J ABEL	JEAN ABEL
+J HUBERT	JEAN HUBERT
+J KARIM	JEAN KARIM
+J CEDRIC	JEAN CEDRIC
+J NOE	JEAN NOE
+J FRANCK	JEAN FRANCK
+J JEROME	JEAN JEROME
+J SIMON	JEAN SIMON
+J EMILIEN	JEAN EMILIEN
+J MAXENCE	JEAN MAXENCE
+J FRED	JEAN FRED
+J VALENTIN	JEAN VALENTIN
+J JOSE	JEAN JOSE
+J MICHEL	JEAN MICHEL
+J RAYMOND	JEAN RAYMOND
+J MARTIAL	JEAN MARTIAL
+J MIKAEL	JEAN MIKAEL
+J ANTHONY	JEAN ANTHONY
+J CLAIR	JEAN CLAIR
+J TOUSSAINT	JEAN TOUSSAINT
+J WILLY	JEAN WILLY
+J FERDINAND	JEAN FERDINAND
+J GABRIEL	JEAN GABRIEL
+J MAURICE	JEAN MAURICE
+J DIDIER	JEAN DIDIER
+J BERTRAND	JEAN BERTRAND
+J GASTON	JEAN GASTON"""

es_normalizer/dictionary/title.py

@@ -0,0 +1,41 @@
+TITLE = """MADAME	2
+MME	2
+MESDAMES	2
+MMES	2
+MADEMOISELLE	2
+MLLE	2
+MESDEMOISELLES	2
+MLLES	2
+MONSIEUR	1
+MR	1
+M	1
+MESSIEURS	1
+MM	1
+VEUVE	2
+VVE	2
+DOCTEUR	0
+DR	0
+DOCTEURS	0
+DRS	0
+PROFESSEUR	0
+PR	0
+PROFESSEURS	0
+PRS	0
+MAITRE	0
+ME	0
+MAITRES	0
+MES	0
+MONSEIGNEUR	1
+MGR	1
+GENERAL	0
+GAL	0
+GNRL	0
+MARECHAL	0
+COLONEL	0
+CEL	0
+CAPITAINE	0
+CNE	0
+COMMANDANT	0
+CDT	0
+LIEUTENANT	0
+LT	0"""

es_normalizer_py-0.2.4.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: es-normalizer-py
+Version: 0.2.4
+Summary: Contact data normalization adapted from the Empreinte Sociométrique's normalizers, the Python port of es-normalizer
+Author-email: Cyril Dever <cdever@pep-s.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cyrildever/es-normalizer-py
+Keywords: data,contact,normalization,empreinte sociometrique
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# es-normalizer-py
+_Contact data normalization adapted from the Empreinte Sociométrique's normalizers (in Python)_
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/es-normalizer-py)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/es-normalizer-py)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/es-normalizer-py)
+![GitHub license](https://img.shields.io/github/license/cyrildever/es-normalizer-py)
+![PyPI - Version](https://img.shields.io/pypi/v/es-normalizer-py)
+
+This is the Python port of [es-normalizer](https://github.com/cyrildever/es-normalizer), the TypeScript normalization library for contact data (address, phones, etc.) adapted from [Edgewhere](https://www.edgewhere.fr)'s Empreinte Sociométrique patented normalizers.
+
+### Motivation
+
+When it comes to hashing data, the necessary uniqueness of the source sometimes makes it hard to compare two hashed data, mostly if dealing with postal address. This library helps normalizing any contact data (the postal or e-mail address, the mobile or landline phone number, the title, names or date of birth of an individual) that would feed any hashing algorithm to make hash comparison always trustable.
+It's based on the work for the Empreinte Sociométrique&trade; patented by Cyril Dever for Edgewhere.
+
+### TypeScript version
+
+The TypeScript library lives at [cyrildever/es-normalizer](https://github.com/cyrildever/es-normalizer) and is published on npm as `es-normalizer`.
+Version `0.2.4` of this port matches its version `2.4.0`: both give the same outputs for the same inputs, the test suite of es-normalizer is ported here case by case, and their dictionaries are the same.
+An address dictionary key may hold several words (eg. `CENTRE COMMERCIAL`), translated together before the single words, the longest first.
+
+### Usage
+
+```
+pip install es-normalizer-py
+```
+
+*IMPORTANT*: as of this version, most normalizers are for use on French data.
+
+To get a normalized string, pass the data and a normalizer function to `normalize()`: it returns the normalized string, or `None` when nothing usable is left.
+There are currently eleven specific normalizer functions and a generic one:
+* `Any`: the generic normalizer should be used if no specific normalizer exists;
+* `AddressLine`: pass any address line through it to get a normalized address, eg. `8, rue Henner` becomes `8 RUE HENNER`, and eventually `True` as parameter when trying to normalize a French address line 1 to also transform the title, eg. `Monsieur Cyril Dever` should then become `1 CYRIL DEVER` when passed `True` instead of `MONSIEUR CYRIL DEVER` for the default behaviour;
+* `AddressLine6`: the French address line 6 with the department inserted in between the zip code and the city as in the Empreinte Sociométrique implementation (eg. `75009 75 PARIS`);
+* `City`: for normalizing city names (it removes any Cedex mention in French address, for instance);
+* `CodePostalFrance`: for French zip code;
+* `DateOfBirth`: pass a date and up to two parameters: the input format (eg. `YYYY-MM-DD`) and the output format wished (eg. `ISO_DATE`), the default values being respectively the ISO format and the French date format;
+* `DepartementFrance`: extract the French departement number (out of a code postal, for instance);
+* `Email`: validates the passed e-mail and returns it in lower-case;
+* `FirstName`: pass a first name and get a normalized one (it uses an enlarged French dictionay of first names to process it making it possible to pass from `"J.-Louis"` to `"JEAN LOUIS"`);
+* `Mobile`: to validate a French mobile phone;
+* `PhoneNumber`: to normalize a French phone or fax number in the international format, eg. `+33 (0) 123 456 789`;
+* `StreetNumber`: parses the passed field to normalize it the Empreinte Sociométrique&trade;'s way, eg. `1bis` or `1 bis` becomes `1B`;
+* `Title`: returns a code depending on the passed string (1 for gentlemen, 2 for ladies, 0 when undefined or unknown).
+
+```python
+from es_normalizer import *
+
+print(normalize('#This is any String(). ', Any))
+# THIS IS ANY STRING
+
+print(normalize('Monsieur Cyril Dever', AddressLine(True)))
+# 1 CYRIL DEVER
+
+print(normalize('24, rué de Maubeuge', AddressLine()))
+# 24 RUE MAUBEUGE
+
+print(normalize('75009 .# Paris', AddressLine6()))
+# 75009 75 PARIS
+
+print(normalize('75009 .# Paris', AddressLine6(False)))
+# 75009 PARIS
+
+print(normalize('Paris Cedex 09', City))
+# PARIS
+
+print(normalize('70/12/01', DateOfBirth('YY/MM/DD', FRENCH_DATE)))
+# 01/12/1970
+
+print(normalize(' 75009 ', DepartementFrance))
+# 75
+
+print(normalize(' Contact@GMAIL.com', Email))
+# contact@gmail.com
+```
+
+`DateOfBirth` reads dates the way the forgiving parser of [moment.js](https://momentjs.com/) does, which es-normalizer relies on. Both give the same date for an input that fits its format; for an input that does not, eg. a numeric date read with a month name format (`DD MMM YYYY`), the guess of each may differ.
+
+### Tests
+
+```console
+$ git clone https://github.com/cyrildever/es-normalizer-py.git
+$ cd es-normalizer-py/
+$ pip install -e .
+$ python3 -m unittest discover
+```
+
+
+### License
+
+This module is distributed under a MIT license. \
+See the [LICENSE](LICENSE) file.
+
+
+<hr />
+&copy; 2026 Cyril Dever. All rights reserved.

es_normalizer_py-0.2.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+es_normalizer/__init__.py,sha256=tVXR6T2qo0Y9PoNy2mXbAlSdLoRU9Nf4ROpK2fRRzoo,8661
+es_normalizer/date_of_birth.py,sha256=6beiq5KDvq_Gz8HL3nB6YYCuqxsLDPTeiIhSvfHzeFE,4237
+es_normalizer/dictionary/__init__.py,sha256=RFC6a90ZzfstjRctQPNG1bf3A8LEqGY6v3GnpyXnZsc,1794
+es_normalizer/dictionary/address.py,sha256=-zhoG_Gov3Bm5tOsRX_xVfk7HUKDenUvIIlvXPkg1GE,1089
+es_normalizer/dictionary/firstname.py,sha256=5EYDLA1vcM1gnO3TQeUI6ss6Rs3l5oHqQMkePmZYQOY,4790
+es_normalizer/dictionary/title.py,sha256=kCMb6w48AysAPoLq_x5g-hdfzfIvoUh3PdZysB9MYKI,370
+es_normalizer_py-0.2.4.dist-info/licenses/LICENSE,sha256=PM4uNGV9-SG80q1m93WGtx-FQooSUK18WonpzGc8mJI,1068
+es_normalizer_py-0.2.4.dist-info/METADATA,sha256=u_YPjKFpxKmI-fcNl1b7nz2SQ-7hfiBGFfl7RAz72O0,5878
+es_normalizer_py-0.2.4.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+es_normalizer_py-0.2.4.dist-info/top_level.txt,sha256=cw6hHhElZgvzvBNuYLouQa8qliIEtZDE0MkB1MzOqQc,14
+es_normalizer_py-0.2.4.dist-info/RECORD,,

es_normalizer_py-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

es_normalizer_py-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cyril Dever
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

es_normalizer_py-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+es_normalizer