add options in parser

Author: remigermain

README.md

@@ -93,10 +93,10 @@ exemple:
 for this working perfectly you need to follow this rules:
 
 - a first key need to be set ex: 'title[0]' or 'title', in both the first key is 'title'
-- each sub key need to enclose by brackets "[--your-key--]"
+- each sub key need to seperate by brackets "[--your-key--]" or dot "." (depends of your options)
 - if sub key are a full number, is converted to list
 - if sub key is Not a number is converted to dictionary
-- the key can't be rewite
+- by default,the duplicate keys can't be set (see options to override that)
   ex:
 
 ```python
@@ -117,7 +117,7 @@ for this working perfectly you need to follow this rules:
 	# ERROR , you set a number is upper thans actual list
 
 
-	# wrong format
+	# wrong format if separator is brackets (see options)
 	data = {
 		'title[0]]]': 'my-value',
 		'title[0': 'my-value',
@@ -162,7 +162,12 @@ for this working perfectly you need to follow this rules:
 	data = {
 		'the[0][chained][key][0][are][awesome][0][0]': 'im here !!'
 	}
-	# output
+	# with "dot" separator in options is ;look like that
+	data = {
+		'the.0.chained.key.0.are.awesome.0.0': 'im here !!'
+	}
+
+	# the output
 	output: {
 		'the': [
 			{
@@ -185,6 +190,88 @@ for this working perfectly you need to follow this rules:
 	}
 ```
 
+# How to use it
+
+## for every framwork
+
+```python
+from nested_multipart_parser import NestedParser
+
+options = {
+	"separator": "bracket"
+}
+
+def my_view():
+	# options is optional
+	parser = NestedParser(data, options)
+	if parser.is_valid():
+		validate_data = parser.validate_data
+		...
+	else:
+		print(parser.errors)
+
+```
+
+## for django rest framwork
+
+```python
+from nested_multipart_parser.drf import DrfNestedParser
+...
+
+class YourViewSet(viewsets.ViewSet):
+	parser_classes = (DrfNestedParser,)
+```
+
+## options
+
+```python
+{
+	# the separator
+	# with bracket:  article[title][authors][0]: "jhon doe"
+	# with dot:      article.title.authors.0: "jhon doe"
+	'separator': 'bracket' or 'dot', # default is bracket
+
+	# raise a expections when you have duplicate keys
+	# ex :
+	# {
+	#	"article": 42,
+	#	"article[title]": 42,
+	# }
+	'raise_duplicate': True,
+
+	# overide the duplicate keys, you need to set "raise_duplicate" to False
+	# ex :
+	# {
+	#	"article": 42,
+	#	"article[title]": 42,
+	# }
+	# the out is
+	# ex :
+	# {
+	#	"article"{
+	# 		"title": 42,
+	#	}
+	# }
+	'assign_duplicate': False
+}
+```
+
+## options with django rest framwork
+
+In your settings.py, add "DRF_NESTED_MULTIPART_PARSER"
+
+```python
+#settings.py
+...
+
+DRF_NESTED_MULTIPART_PARSER = {
+	"separator": "bracket",
+	"raise_duplicate": True,
+	"assign_duplicate": False
+
+}
+```
+
+## for frontend javscript
 
-## Javscript
 You can use this [multipart-object](https://github.com/remigermain/multipart-object) library to easy convert object to flat nested object formated for this library

nested_multipart_parser/drf.py

@@ -2,10 +2,14 @@
 from rest_framework.parsers import MultiPartParser
 from django.http.multipartparser import MultiPartParserError
 from django.http import QueryDict
+from django.conf import settings
 
 
 class NestedParser(NestPars):
 
+    def __init__(self, data):
+        super().__init__(data, getattr(settings, "DRF_NESTED_MULTIPART_PARSER", {}))
+
     @property
     def validate_data(self):
         dtc = QueryDict(mutable=True)

nested_multipart_parser/parser.py

@@ -4,61 +4,110 @@
 class NestedParser:
     _valid = None
     errors = None
-    _reg = re.compile(r"\[|\]")
 
-    def __init__(self, data):
+    def __init__(self, data, options={}):
         self.data = data
+        self._merge_options(options)
+
+    def _merge_options(self, options):
+        DEFAULT_OPTIONS = {
+            "separator": "bracket",
+            "raise_duplicate": True,
+            "assign_duplicate": False
+        }
+
+        options = {**DEFAULT_OPTIONS, **options}
+        self._options = options
+
+        assert self._options.get("separator", "dot") in ["dot", "bracket"]
+        assert isinstance(self._options.get("raise_duplicate", False), bool)
+        assert isinstance(self._options.get("assign_duplicate", False), bool)
+
+        self._is_dot = self._options["separator"] == "dot"
+        if not self.is_dot:
+            self._reg = re.compile(r"\[|\]")
+
+    @property
+    def is_dot(self):
+        return self._is_dot
 
     def split_key(self, key):
         # remove space
         k = key.replace(" ", "")
+
         # remove empty string and count key length for check is a good format
         # reduce + filter are a hight cost so do manualy with for loop
-        results = []
-        check = -2
 
-        for select in self._reg.split(k):
+        # optimize by split with string func
+        if self.is_dot:
+            length = 1
+            splitter = k.split(".")
+        else:
+            splitter = self._reg.split(k)
+            length = 2
+
+        check = -length
+
+        results = []
+        for select in splitter:
             if select:
                 results.append(select)
-                check += len(select) + 2
+                check += len(select) + length
 
         if len(k) != check:
             raise Exception(f"invalid format from key {key}")
         return results
 
-    def set_type(self, dtc, key, value, full_keys):
+    def set_type(self, dtc, key, value, full_keys, prev=None, last=False):
         if isinstance(dtc, list):
             key = int(key)
             if len(dtc) < key:
                 raise ValueError(
                     f"key \"{full_keys}\" is upper than actual list")
             if len(dtc) == key:
                 dtc.append(value)
-                return key
         elif isinstance(dtc, dict):
-            if key not in dtc:
+            if key not in dtc or self._options["assign_duplicate"] and last:
                 dtc[key] = value
         else:
-            raise ValueError(
-                f"invalid rewrite key from \"{full_keys}\" to \"{dtc}\"")
+            if self._options["raise_duplicate"]:
+                raise ValueError(
+                    f"invalid rewrite key from \"{full_keys}\" to \"{dtc}\"")
+            elif self._options["assign_duplicate"]:
+                dtc = prev['dtc']
+                dtc[prev['key']] = prev['type']
+                return self.set_type(dtc[prev['key']], key, value, full_keys, prev, last)
         return key
 
+    def get_next_type(self, keys):
+        return [] if keys.isdigit() else {}
+
     def construct(self, data):
         dictionary = {}
 
         for key in data:
             keys = self.split_key(key)
             tmp = dictionary
+            prev = {
+                'key': keys[0],
+                'dtc': tmp,
+                'type': None
+            }
 
             # optimize with while loop instend of for in with zip function
             i = 0
             lenght = len(keys) - 1
             while i < lenght:
-                set_type = [] if keys[i+1].isdigit() else {}
-                tmp = tmp[self.set_type(tmp, keys[i], set_type, key)]
+                set_type = self.get_next_type(keys[i+1])
+                index = self.set_type(
+                    tmp, keys[i], set_type, key, prev=prev)
+                prev['dtc'] = tmp
+                prev['key'] = index
+                prev['type'] = set_type
+                tmp = tmp[index]
                 i += 1
 
-            self.set_type(tmp, keys[-1], data[key], key)
+            self.set_type(tmp, keys[-1], data[key], key, prev=prev, last=True)
         return dictionary
 
     def is_valid(self):

setup.py

@@ -23,7 +23,7 @@
 
 setuptools.setup(
     name="nested-multipart-parser",
-    version="0.1.0",
+    version="0.2.0",
     author="Example Author",
     license='MIT',
     author_email='contact@germainremi.fr',

tests/test_drf.py

@@ -2,6 +2,13 @@
 from django.http import QueryDict
 
 
+def toQueryDict(data):
+    q = QueryDict(mutable=True)
+    q.update(data)
+    q._mutable = False
+    return q
+
+
 class TestDrfParser(unittest.TestCase):
 
     @classmethod
@@ -24,8 +31,7 @@ def test_querydict_mutable(self):
             }
         )
         self.assertTrue(parser.is_valid())
-        q = QueryDict(mutable=True)
-        q.update({
+        q = toQueryDict({
             "dtc": {
                 "key": "value",
                 "vla": "value2",
@@ -40,6 +46,34 @@ def test_querydict_mutable(self):
             ],
             "string": "value",
         })
-        q.mutable = False
         self.assertEqual(parser.validate_data, q)
         self.assertFalse(parser.validate_data.mutable)
+
+    def test_settings(self):
+        from nested_multipart_parser.drf import NestedParser
+
+        data = {
+            "article.title": "youpi"
+        }
+        p = NestedParser(data)
+        self.assertTrue(p.is_valid())
+        expected = toQueryDict({
+            "article.title": "youpi"
+        })
+        self.assertEqual(p.validate_data, expected)
+
+        # set settings
+        from django.conf import settings
+        options = {
+            "separator": "dot"
+        }
+        setattr(settings, 'DRF_NESTED_MULTIPART_PARSER', options)
+
+        p = NestedParser(data)
+        self.assertTrue(p.is_valid())
+        expected = toQueryDict({
+            "article": {
+                "title": "youpi"
+            }
+        })
+        self.assertEqual(p.validate_data, expected)

tests/test_parser.py

@@ -295,3 +295,20 @@ def test_parser_rewrite_key_boject(self):
         }
         parser = NestedParser(data)
         self.assertFalse(parser.is_valid())
+
+    def test_wrong_settings(self):
+
+        data = {"data": "data"}
+
+        with self.assertRaises(AssertionError):
+            NestedParser(data, options={
+                "separator": "worng"
+            })
+        with self.assertRaises(AssertionError):
+            NestedParser(data, options={
+                "raise_duplicate": "need_boolean"
+            })
+        with self.assertRaises(AssertionError):
+            NestedParser(data, options={
+                "assign_duplicate": "need_boolean"
+            })