feat: replace NestedElement to tempElement

Author: remigermain

nested_multipart_parser/declare.py

@@ -1,11 +1,10 @@
-from nested_multipart_parser.declare import NestedDeclare
 from nested_multipart_parser.options import (
-    NestedParserOptionsMixedDot,
-    NestedParserOptionsMixed,
     NestedParserOptionsBracket,
     NestedParserOptionsDot,
+    NestedParserOptionsMixed,
+    NestedParserOptionsMixedDot,
 )
-
+from nested_multipart_parser.temp_element import TempDict, TempList
 
 DEFAULT_OPTIONS = {
     "separator": "mixed-dot",
@@ -29,7 +28,12 @@ def __init__(self, data, options={}):
         self.data = data
         self._options = {**DEFAULT_OPTIONS, **options}
 
-        assert self._options["separator"] in ["dot", "bracket", "mixed", "mixed-dot"]
+        assert self._options["separator"] in [
+            "dot",
+            "bracket",
+            "mixed",
+            "mixed-dot",
+        ]
         assert isinstance(self._options["raise_duplicate"], bool)
         assert isinstance(self._options["assign_duplicate"], bool)
 
@@ -47,16 +51,16 @@ def convert_value(self, value):
         return value
 
     def construct(self, data):
-        dictionary = NestedDeclare(dict, self._options)
+        dictionary = TempDict(self._options)
 
         for keys, value in self._split_keys(data):
             tmp = dictionary
 
             for actual_key, next_key in zip(keys, keys[1:]):
                 if isinstance(next_key, int):
-                    tmp[actual_key] = NestedDeclare(list, self._options)
+                    tmp[actual_key] = TempList(self._options)
                 else:
-                    tmp[actual_key] = NestedDeclare(dict, self._options)
+                    tmp[actual_key] = TempDict(self._options)
                 tmp = tmp[actual_key]
 
             tmp[keys[-1]] = self.convert_value(value)

nested_multipart_parser/parser.py

@@ -0,0 +1,73 @@
+import abc
+from typing import Any
+
+
+class TempElement(abc.ABC):
+    @abc.abstractclassmethod
+    def __setitem__(self, key, val):
+        """method to set element"""
+
+    def check(self, key, value):
+        if key in self._elements:
+            # same instance like templist to templist, we ignore it
+            if isinstance(self._elements[key], type(value)):
+                return
+
+            if self._options.get("raise_duplicate"):
+                raise ValueError("key is already set")
+
+            if not self._options.get("assign_duplicate"):
+                return
+
+        self._elements[key] = value
+
+    def __getitem__(self, key):
+        if key not in self._elements:
+            self[key] = type(self)(options=self._options)
+        return self._elements[key]
+
+    def conv_value(self, value: Any) -> Any:
+        if isinstance(value, TempElement):
+            value = value.convert()
+        return value
+
+    @abc.abstractmethod
+    def convert(self):
+        """method to convert tempoary element to real python element"""
+
+
+class TempList(TempElement):
+    def __init__(self, options=None):
+        self._options = options or {}
+        self._elements = {}
+
+    def __setitem__(self, key: int, value: Any):
+        assert isinstance(key, int), (
+            f"Invalid key for list, need to be int, type={type(key)}"
+        )
+        self.check(key, value)
+
+    def convert(self) -> list:
+        keys = sorted(self._elements.keys())
+        # check if index start to 0 and end to number of elements
+        if any((keys[0] != 0, keys[-1] != (len(self._elements) - 1))):
+            raise ValueError("invalid format list keys")
+
+        return [self.conv_value(self._elements[key]) for key in keys]
+
+
+class TempDict(TempElement):
+    def __init__(self, options=None):
+        self._options = options or {}
+        self._elements = {}
+
+    def __setitem__(self, key: str, value: Any):
+        assert isinstance(key, str), (
+            f"Invalid key for dict, need to be str, type={type(key)}"
+        )
+        self.check(key, value)
+
+    def convert(self) -> dict:
+        return {
+            key: self.conv_value(value) for key, value in self._elements.items()
+        }