Refactor: Replace validation strict parameter with options object

pyproject.toml

@@ -21,7 +21,7 @@ shapely = "^2.0.2"
 [tool.poetry.group.linting.dependencies]
 black = "^23.12.1"
 isort = "^5.13.2"
-pyright = "^1.1.347"
+pyright = "^1.1.369"
 flake8 = "^7.0.0"
 
 

src/frformat/__init__.py

@@ -1,6 +1,5 @@
 # flake8: noqa
 from .custom_format import *  # isort:skip
-
 from .code_rna import CodeRNA as CodeRNA
 from .geo.canton import Canton as Canton
 from .geo.code_commune_insee import CodeCommuneInsee as CodeCommuneInsee
@@ -20,5 +19,6 @@
 from .geo.pays import Pays as Pays
 from .geo.region import Region as Region
 from .nomenclature_acte_format import NomenclatureActe as NomenclatureActe
+from .options import Options
 from .siren import Siren as Siren
 from .siret import Siret as Siret

src/frformat/common.py

@@ -1,19 +1,27 @@
 import re
 
+from frformat.options import Options
+
 NBSP = "\u00A0"  # Non-breaking space
 NNBSP = "\u202F"  # Narrow non-breaking space
 
 
-def normalize_text(val: str) -> str:
-    val = val.lower()
-    val = val.replace("-", " ")
-    val = val.replace("_", " ")
-    val = val.replace("'", " ")
-    val = val.replace(",", " ")
-    val = val.replace("  ", " ")
-    val = re.sub(r"[èéêë]", "e", val)
-    val = re.sub(r"[àáâãäå]", "a", val)
-    val = re.sub(r"[ìíîï]", "i", val)
-    val = re.sub(r"[òóôõö]", "o", val)
-    val = re.sub(r"[ùúûü]", "u", val)
+def normalize_value(val: str, options: Options) -> str:
+    if options.ignore_case is True:
+        val = val.lower()
+
+    if options.ignore_accents is True:
+        val = re.sub(r"[èéêë]", "e", val)
+        val = re.sub(r"[àáâãäå]", "a", val)
+        val = re.sub(r"[ìíîï]", "i", val)
+        val = re.sub(r"[òóôõö]", "o", val)
+        val = re.sub(r"[ùúûü]", "u", val)
+
+    if options.ignore_non_alphanumeric is True:
+        val = re.sub(r"[^a-zA-Z0-9]", " ", val)
+
+    if options.ignore_extra_white_space is True:
+        val = val.strip()
+        val = val.replace("  ", " ")
+
     return val

src/frformat/enum_format.py

@@ -1,35 +1,24 @@
-from typing import Optional, Set, Type
+from typing import Set, Type
 
 from frformat import CustomStrFormat, Metadata
-from frformat.common import normalize_text
+from frformat.common import normalize_value
+from frformat.options import Options
 
 
-def new(
-    class_name: str,
-    name: str,
-    description: str,
-    strict_enum: Set[str],
-    lenient_enum: Optional[Set[str]] = None,
-) -> Type:
-    if not lenient_enum:
-        lenient_enum = {normalize_text(e) for e in strict_enum}
-
+def new(class_name: str, name: str, description: str, enum: Set[str]) -> Type:
     class EnumFormat(CustomStrFormat):
         """Checks if a value is in a given list
 
-        May check with or without string normalization with the "strict"
-        validation.
-        """
+        May check with string normalization with the "options" of validation."""
 
         metadata = Metadata(name, description)
 
         @classmethod
-        def is_valid(cls, value: str, strict: bool = True) -> bool:
-            if not strict:
-                norm_value = normalize_text(value)
-                return norm_value in lenient_enum
-            else:
-                return value in strict_enum
+        def is_valid(cls, value: str, options: Options = Options()) -> bool:
+            normalized_enum = {normalize_value(e, options) for e in enum}
+            normalized_value = normalize_value(value, options)
+
+            return normalized_value in normalized_enum
 
     EnumFormat.__name__ = class_name
     EnumFormat.__qualname__ = class_name

src/frformat/geo/code_fantoir.py

@@ -3,6 +3,7 @@
 from frformat import CustomStrFormat, Metadata
 from frformat.formatter import Formatter
 from frformat.geo.code_fantoir_set import PARTIAL_CODE_FANTOIR_SET
+from frformat.options import Options
 
 name = "Code fantoir"
 description = "Vérifie les codes fantoirs valides"
@@ -20,7 +21,7 @@ class CodeFantoir(CustomStrFormat):
     formatter = CodeFantoirFormatter()
 
     @classmethod
-    def is_valid(cls, value: str) -> bool:
+    def is_valid(cls, value: str, options: Options = Options()) -> bool:
         if len(value) != 5:
             return False
 

src/frformat/geo/region.py

@@ -1,9 +1,9 @@
 from frformat import enum_format
-from frformat.geo.region_set import LENIENT_REGION_SET, REGION_SET
+from frformat.geo.region_set import REGION_SET
 
 name = "Nom de région"
 description = (
     "Vérifie les régions françaises valides (code officiel géographique 2020) "
 )
 
-Region = enum_format.new("Region", name, description, REGION_SET, LENIENT_REGION_SET)
+Region = enum_format.new("Region", name, description, REGION_SET)

src/frformat/geo/region_set.py

@@ -18,52 +18,3 @@
     "Provence-Alpes-Côte d'Azur",
     "Corse",
 }
-
-LENIENT_REGION_SET = {
-    "alsace",
-    "aquitaine",
-    "ara",
-    "aura",
-    "auvergne",
-    "auvergne et rhone alpes",
-    "auvergne rhone alpes",
-    "basse normandie",
-    "bfc",
-    "bourgogne",
-    "bourgogne et franche comte",
-    "bourgogne franche comte",
-    "bretagne",
-    "centre",
-    "centre val de loire",
-    "champagne ardenne",
-    "corse",
-    "franche comte",
-    "ge",
-    "nouvelle aquitaine",
-    "grand est",
-    "guadeloupe",
-    "guyane",
-    "haute normandie",
-    "hauts de france",
-    "hdf",
-    "ile de france",
-    "languedoc roussillon",
-    "la reunion",
-    "la reunion",
-    "limousin",
-    "lorraine",
-    "martinique",
-    "mayotte",
-    "midi pyrenees",
-    "nord pas de calais",
-    "normandie",
-    "npdc",
-    "occitanie",
-    "paca",
-    "pays de la loire",
-    "picardie",
-    "poitou charentes",
-    "provence alpes cote d azur",
-    "reunion",
-    "rhone alpes",
-}

src/frformat/options.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Options:
+    """
+       The class Options is used to represent a list of necessary options to validate a French format.
+
+    Attributes:
+        ignore_case: Boolean
+            Indicates if case should be ignored.
+            When set to True, all characters in the string will be converted to lowercase.
+
+        ignore_accents: Boolean
+            Indicates if accents should be ignored.
+            When set to True, characters with accents will be replaced with their non-accented counterparts.
+            Example: 'à' will be replaced by 'a'.
+
+        ignore_non_alphanumeric: Boolean
+            Indicates if non-alphanumeric characters should be ignored.
+            When set to True, punctuation marks and symbols will be replaced by a space.
+
+        ignore_extra_white_space: Boolean
+            Indicates if extra white space should be ignored.
+            When set to True, multiple consecutive spaces will be treated as a single space, and leading or trailing spaces will be removed.
+
+        extra_valid_values: set of string
+            A collection of additional valid values.
+            This set includes any extra values that should be considered valid during the validation process, beyond the original set of valid values.
+            This allows for customized validation rules to accommodate special cases or exceptions.
+    """
+
+    ignore_case: bool = False
+    ignore_accents: bool = False
+    ignore_non_alphanumeric: bool = False
+    ignore_extra_white_space: bool = False
+    extra_valid_values: set = field(default_factory=set)

src/tests/test_geo_fr.py

@@ -15,6 +15,7 @@
     Region,
 )
 from frformat.common import NBSP, NNBSP
+from frformat.options import Options
 from tests.testing import (
     strict_lenient_test_helper_factory,
     validation_test_helper_factory,
@@ -27,8 +28,8 @@ def test_code_fantoir():
     fantoir_valid = ["ZB03A"]
     fantoir_invalid = ["1000"]
 
-    _test_fantoir(fantoir_valid, True)
-    _test_fantoir(fantoir_invalid, False)
+    _test_fantoir(fantoir_valid, True, Options())
+    _test_fantoir(fantoir_invalid, False, Options())
 
 
 def test_code_commune_insee():
@@ -134,14 +135,7 @@ def test_region():
     _test_region = strict_lenient_test_helper_factory(Region)
 
     region_strict = ["Centre-Val de Loire", "La Réunion", "Corse"]
-    region_lenient = [
-        "Centre Val de Loire",
-        "La Reunion",
-        "corse",
-        "bfc",
-        "BFC",
-        "aura",
-    ]
+    region_lenient = ["Centre Val de Loire", "La Reunion", "corse"]
     region_invalid = ["Beleriand", "Canyon Cosmo"]
 
     _test_region(region_strict, region_lenient, region_invalid)

src/tests/testing.py

@@ -1,22 +1,20 @@
 from typing import List
 
+from frformat.options import Options
 
-def validation_test_helper_factory(Class):
-    def test_helper(test_cases: List[str], expectValid: bool, **kwargs) -> None:
-        isStrict = kwargs["strict"] if "strict" in kwargs else None
 
-        if isStrict:
+def validation_test_helper_factory(Class):
+    def test_helper(test_cases: List[str], expectValid: bool, options: Options) -> None:
+        if options == Options():
             adjective = "strictly"
-        elif isStrict is False:
-            adjective = "leniently"
         else:
-            adjective = ""
+            adjective = "leniently"
 
         validKeywoard = "valid" if expectValid else "invalid"
 
         for tc in test_cases:
             assert (
-                Class.is_valid(tc, **kwargs) == expectValid
+                Class.is_valid(tc, options) == expectValid
             ), f"Check that { Class.__name__ } { tc } is { adjective } { validKeywoard }"
 
     return test_helper
@@ -33,12 +31,18 @@ def test_helper(
         lenient_test_cases: List[str],
         invalid_test_cases: List[str],
     ) -> None:
-        _test_class(strict_test_cases, expectValid=True, strict=True)
-        _test_class(lenient_test_cases, expectValid=False, strict=True)
-        _test_class(invalid_test_cases, expectValid=False, strict=True)
-
-        _test_class(strict_test_cases, expectValid=True, strict=False)
-        _test_class(lenient_test_cases, expectValid=True, strict=False)
-        _test_class(invalid_test_cases, expectValid=False, strict=False)
+        optionsTrue = Options(
+            ignore_case=True,
+            ignore_non_alphanumeric=True,
+            ignore_extra_white_space=True,
+            ignore_accents=True,
+        )
+        _test_class(strict_test_cases, expectValid=True, options=Options())
+        _test_class(lenient_test_cases, expectValid=False, options=Options())
+        _test_class(invalid_test_cases, expectValid=False, options=Options())
+
+        _test_class(strict_test_cases, expectValid=True, options=optionsTrue)
+        _test_class(lenient_test_cases, expectValid=True, options=optionsTrue)
+        _test_class(invalid_test_cases, expectValid=False, options=optionsTrue)
 
     return test_helper