es-normalizer-py 0.2.4__tar.gz

es_normalizer_py-0.2.4/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/MANIFEST.in

@@ -0,0 +1,3 @@
+# MANIFEST.in
+
+exclude publish.sh

es_normalizer_py-0.2.4/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,97 @@
+# 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™ 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™'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/pyproject.toml

@@ -0,0 +1,29 @@
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools>=77.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "es-normalizer-py"
+version = "0.2.4"
+description = "Contact data normalization adapted from the Empreinte Sociométrique's normalizers, the Python port of es-normalizer"
+readme = "README.md"
+authors = [{ name = "Cyril Dever", email = "cdever@pep-s.com" }]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "data",
+    "contact",
+    "normalization",
+    "empreinte sociometrique",
+]
+dependencies = []
+requires-python = ">=3.10.2"
+
+[project.urls]
+Homepage = "https://github.com/cyrildever/es-normalizer-py"

es_normalizer_py-0.2.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

es_normalizer_py-0.2.4/src/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_py-0.2.4/src/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