feat: add lazy regex

Author: remigermain

nested_multipart_parser/lazy.py

@@ -0,0 +1,12 @@
+import re
+
+# compatibilty python < 3.9
+try:
+    from functools import cache
+except ImportError:
+    from functools import lru_cache as cache
+
+
+@cache
+def lazy_regex_compile(*ar, **kw):
+    return re.compile(*ar, **kw)

nested_multipart_parser/options.py

@@ -1,4 +1,4 @@
-import re
+from nested_multipart_parser.lazy import lazy_regex_compile
 
 
 class InvalidFormat(Exception):
@@ -16,7 +16,7 @@ def __new__(cls, cls_name, ns, childs):
         return super().__new__(cls, cls_name, ns, childs)
 
 
-TOKEN_PARSER = ("[", "]", ".")
+INVALID_TOKEN_PARSER = ("[", "]", ".")
 
 
 class NestedParserOptionsAbstract(metaclass=NestedParserOptionsType):
@@ -25,7 +25,7 @@ def check(self, key, keys):
             raise InvalidFormat(key)
 
         first = keys[0]
-        for token in TOKEN_PARSER:
+        for token in INVALID_TOKEN_PARSER:
             if token in first:
                 raise InvalidFormat(key)
 
@@ -35,7 +35,7 @@ def check(self, key, keys):
             for c in key:
                 if c.isspace():
                     raise InvalidFormat(key)
-    
+
     def split(self, key):
         contents = list(filter(None, self._reg_spliter.split(key)))
         if not contents:
@@ -50,18 +50,10 @@ def split(self, key):
         return list(filter(None, lst))
 
 
-REGEX_SEPARATOR = {
-    "dot": r"(\.[^\.]+)",
-    "bracket": r"([^\[\]]+)",
-    "mixed": r"(\[\d+\])|([^\[\]]+)",
-    "mixed-dot": r"(\[\d+\])|(\.[^\[\]\.]+)",
-}
-
-
 class NestedParserOptionsDot(NestedParserOptionsAbstract):
     def __init__(self):
-        self._reg_spliter = re.compile(r"^([^\.]+)(.*?)(\.)?$")
-        self._reg_options = re.compile(r"(\.[^\.]+)")
+        self._reg_spliter = lazy_regex_compile(r"^([^\.]+)(.*?)(\.)?$")
+        self._reg_options = lazy_regex_compile(r"(\.[^\.]+)")
 
     def sanitize(self, key, value):
         contents = self.split(key)
@@ -88,8 +80,8 @@ def sanitize(self, key, value):
 
 class NestedParserOptionsBracket(NestedParserOptionsAbstract):
     def __init__(self):
-        self._reg_spliter = re.compile(r"^([^\[\]]+)(.*?)(\[\])?$")
-        self._reg_options = re.compile(r"(\[[^\[\]]+\])")
+        self._reg_spliter = lazy_regex_compile(r"^([^\[\]]+)(.*?)(\[\])?$")
+        self._reg_options = lazy_regex_compile(r"(\[[^\[\]]+\])")
 
     def sanitize(self, key, value):
         first, *lst = self.split(key)
@@ -117,8 +109,10 @@ def sanitize(self, key, value):
 
 class NestedParserOptionsMixedDot(NestedParserOptionsAbstract):
     def __init__(self):
-        self._reg_spliter = re.compile(r"^([^\[\]\.]+)(.*?)((?:\.)|(?:\[\]))?$")
-        self._reg_options = re.compile(r"(\[\d+\])|(\.[^\[\]\.]+)")
+        self._reg_spliter = lazy_regex_compile(
+            r"^([^\[\]\.]+)(.*?)((?:\.)|(?:\[\]))?$"
+        )
+        self._reg_options = lazy_regex_compile(r"(\[\d+\])|(\.[^\[\]\.]+)")
 
     def sanitize(self, key, value):
         first, *lst = self.split(key)
@@ -152,8 +146,10 @@ def sanitize(self, key, value):
 
 class NestedParserOptionsMixed(NestedParserOptionsMixedDot):
     def __init__(self):
-        self._reg_spliter = re.compile(r"^([^\[\]\.]+)(.*?)((?:\.)|(?:\[\]))?$")
-        self._reg_options = re.compile(r"(\[\d+\])|(\.?[^\[\]\.]+)")
+        self._reg_spliter = lazy_regex_compile(
+            r"^([^\[\]\.]+)(.*?)((?:\.)|(?:\[\]))?$"
+        )
+        self._reg_options = lazy_regex_compile(r"(\[\d+\])|(\.?[^\[\]\.]+)")
 
     def sanitize(self, key, value):
         first, *lst = self.split(key)

nested_multipart_parser/parser.py

@@ -24,9 +24,9 @@ class NestedParser:
     _valid = None
     errors = None
 
-    def __init__(self, data, options={}):
+    def __init__(self, data, options=None):
         self.data = data
-        self._options = {**DEFAULT_OPTIONS, **options}
+        self._options = {**DEFAULT_OPTIONS, **(options or {})}
 
         assert self._options["separator"] in [
             "dot",
@@ -40,8 +40,8 @@ def __init__(self, data, options={}):
         self._cls_options = REGEX_SEPARATOR[self._options["separator"]]
 
     def _split_keys(self, data):
+        checker = self._cls_options()
         for key, value in data.items():
-            checker = self._cls_options()
             keys, value = checker.sanitize(key, value)
             checker.check(key, keys)