add trim unrequired keys

Author: y1xiaoc

dargs/dargs.py

@@ -21,6 +21,7 @@
 from typing import Union, Any, List, Iterable, Optional, Callable
 from textwrap import wrap, fill, indent
 from copy import deepcopy
+import fnmatch, re
 
 
 INDENT = "    " # doc is indented by four spaces
@@ -149,6 +150,10 @@ def _traverse_subvariant(self, value: dict, *args, **kwargs):
     # below are type checking part
 
     def check(self, argdict: dict, strict: bool = False):
+        if strict and len(argdict) != 1:
+            raise KeyError("only one single key of arg name is allowed "
+                           "for check in strict mode at top level, "
+                           "use check_value if you are checking subfields")
         self.traverse(argdict, 
             key_hook=Argument._check_exist,
             value_hook=Argument._check_dtype,
@@ -170,7 +175,7 @@ def _check_exist(self, argdict: dict):
     def _check_dtype(self, value: Any):
         if not isinstance(value, self.dtype):
             raise TypeError(f"key `{self.name}` gets wrong value type: "
-                            f"requires: {self.dtype} but gets {type(value)}")
+                            f"requires {self.dtype} but gets {type(value)}")
 
     def _check_strict(self, value: dict):
         allowed = self._get_allowed_sub(value)
@@ -181,7 +186,7 @@ def _check_strict(self, value: dict):
                 raise KeyError(f"undefined key `{name}` is "
                                 "not allowed in strict mode")
 
-    def _get_allowed_sub(self, value: dict):
+    def _get_allowed_sub(self, value: dict) -> List[str]:
         allowed = [subarg.name for subarg in self.sub_fields]
         for subvrnt in self.sub_variants:
             allowed.extend(subvrnt._get_allowed_sub(value))
@@ -191,23 +196,32 @@ def _get_allowed_sub(self, value: dict):
     # below are normalizing part
 
     def normalize(self, argdict: dict, inplace: bool = False, 
-                  do_default: bool = True, do_alias: bool = True):
+                  do_default: bool = True, do_alias: bool = True, 
+                  trim_pattern: Optional[str] = None):
         if not inplace:
             argdict = deepcopy(argdict)
         if do_alias:
             self.traverse(argdict, key_hook=Argument._convert_alias)
         if do_default:
             self.traverse(argdict, key_hook=Argument._assign_default)
+        if trim_pattern is not None:
+            self._trim_unrequired(argdict, trim_pattern, reserved=[self.name])
+            self.traverse(argdict, sub_hook=lambda a, d: 
+                Argument._trim_unrequired(d, trim_pattern, a._get_allowed_sub(d)))
         return argdict
 
     def normalize_value(self, value: Any, inplace: bool = False, 
-                        do_default: bool = True, do_alias: bool = True):
+                        do_default: bool = True, do_alias: bool = True, 
+                        trim_pattern: Optional[str] = None):
         if not inplace:
             value = deepcopy(value)
         if do_alias:
             self.traverse_value(value, key_hook=Argument._convert_alias)
         if do_default:
             self.traverse_value(value, key_hook=Argument._assign_default)
+        if trim_pattern is not None:
+            self.traverse_value(value, sub_hook=lambda a, d: 
+                Argument._trim_unrequired(d, trim_pattern, a._get_allowed_sub(d)))
         return value
 
     def _assign_default(self, argdict: dict):
@@ -221,6 +235,21 @@ def _convert_alias(self, argdict: dict):
                     argdict[self.name] = argdict.pop(alias)
                     return
 
+    @staticmethod
+    def _trim_unrequired(argdict: dict, pattern: str, 
+                         reserved: Optional[List[str]] = None,
+                         use_regex: bool = False):
+        rep = fnmatch.translate(pattern) if not use_regex else pattern
+        rem = re.compile(rep)
+        if reserved:
+            conflict = list(filter(rem.match, reserved))
+            if conflict:
+                raise ValueError(f"pattern `{pattern}` conflicts with the "
+                                 f"following reserved names: {', '.join(conflict)}")
+        unrequired = list(filter(rem.match, argdict.keys()))
+        for key in unrequired:
+            argdict.pop(key)
+
     # above are normalizing part
     # below are doc generation part
 

tests/test_checker.py

@@ -17,6 +17,8 @@ def test_name_type(self):
         # possible error
         with self.assertRaises(KeyError):
             ca.check({"key2": 1})
+        with self.assertRaises(KeyError):
+            ca.check({"key1": 1, "key2": 1}, strict=True)
         with self.assertRaises(TypeError):
             ca.check({"key1": 1.0})
         # special handle of None

tests/test_normalization.py

@@ -34,6 +34,22 @@ def test_alias(self):
         self.assertDictEqual(end1, ref)
         self.assertTrue(end1 is beg1)
 
+    def test_trim(self):
+        ca = Argument("Key1", int)
+        beg = {"Key1": 1, "_comment": 123}
+        end = ca.normalize(beg, trim_pattern="_*")
+        ref = {"Key1": 1}
+        self.assertTrue(end == ref)
+        self.assertTrue(beg == {"Key1": 1, "_comment": 123})
+        self.assertTrue(end is not beg)
+        # conflict pattern
+        with self.assertRaises(ValueError):
+            ca.normalize(beg, trim_pattern="Key1")
+        # inplace
+        end1 = ca.normalize(beg, inplace=True, trim_pattern="_*")
+        self.assertTrue(end1 == ref)
+        self.assertTrue(end1 is beg)
+
     def test_combined(self):
         ca = Argument("base", dict, [
             Argument("sub1", int, optional=True, default=1, alias=["sub1a"]),
@@ -43,10 +59,10 @@ def test_combined(self):
         ref1 = {"base":{"sub1":1, "sub2": "haha"}}
         self.assertDictEqual(ca.normalize(beg1), ref1)
         self.assertDictEqual(ca.normalize_value(beg1["base"]), ref1["base"])
-        beg2 = {"base":{"sub1a": 2, "sub2a": "hoho"}}
+        beg2 = {"base":{"sub1a": 2, "sub2a": "hoho", "_comment": None}}
         ref2 = {"base":{"sub1": 2, "sub2": "hoho"}}
-        self.assertDictEqual(ca.normalize(beg2), ref2)
-        self.assertDictEqual(ca.normalize_value(beg2["base"]), ref2["base"])
+        self.assertDictEqual(ca.normalize(beg2, trim_pattern="_*"), ref2)
+        self.assertDictEqual(ca.normalize_value(beg2["base"], trim_pattern="_*"), ref2["base"])
 
     def test_complicated(self):
         ca = Argument("base", dict, [
@@ -79,10 +95,11 @@ def test_complicated(self):
         beg2 = {
             "base": {
                 "sub1a": 2,
-                "sub2a": [{"ss1a":22}, {}],
+                "sub2a": [{"ss1a":22}, {"_comment1": None}],
                 "vnt_flag": "type2",
                 "sharedb": -3,
-                "vnt2a": 223}
+                "vnt2a": 223,
+                "_comment2": None}
         }
         ref2 = {
             'base': {
@@ -92,8 +109,10 @@ def test_complicated(self):
                 'shared': -3, 
                 'vnt2': 223}
         }
-        self.assertDictEqual(ca.normalize(beg2), ref2)
-        self.assertDictEqual(ca.normalize_value(beg2["base"]), ref2["base"])
+        self.assertDictEqual(ca.normalize(beg2, trim_pattern="_*"), ref2)
+        self.assertDictEqual(ca.normalize_value(beg2["base"], trim_pattern="_*"), ref2["base"])
+        with self.assertRaises(ValueError):
+            ca.normalize(beg2, trim_pattern="sub*")
 
 
 if __name__ == "__main__":