Support empty and keyword arguments in update method (eg. update(key=value)). (by [@xiehuanyi](https://github.com/xiehuanyi) in #633)

* Support empty and keyword updates in BaseDict

* Support empty and keyword updates in `KeypathDict` (and `benedict`).

---------

Co-authored-by: Fabio Caccamo <fabio.caccamo@gmail.com>

Author: xiehuanyi

benedict/dicts/base/base_dict.py

@@ -260,13 +260,14 @@ def setdefault(self, key: _K, default: _V | None = None) -> _V:
             return self._dict.setdefault(key, default)
         return super().setdefault(key, default)
 
-    def update(self, other: Any) -> None:
+    def update(self, other: Any = (), /, **kwargs: Any) -> None:
         self._check_frozen()
         other = self._get_dict_or_value(other)
+        kwargs = self._get_dict_or_value(kwargs)
         if self._dict is not None:
-            self._dict.update(other)
+            self._dict.update(other, **kwargs)
             return
-        super().update(other)
+        super().update(other, **kwargs)
 
     def values(self) -> ValuesView[_V]:  # type: ignore[override]
         if self._dict is not None:

benedict/dicts/keypath/keypath_dict.py

@@ -72,6 +72,7 @@ def get(self, key: _K, default: _V | None = None) -> _V | None:  # type: ignore[
     def pop(self, key: _K, *args: Any) -> _V:  # type: ignore[override]
         return super().pop(self._parse_key(key), *args)  # type: ignore[no-any-return]
 
-    def update(self, other: Mapping[Any, _V]) -> None:  # type: ignore[override]
+    def update(self, other: Any = (), /, **kwargs: Any) -> None:
         keypath_util.check_keys(other, self._keypath_separator)
-        super().update(other)
+        keypath_util.check_keys(kwargs, self._keypath_separator)
+        super().update(other, **kwargs)

tests/dicts/base/test_base_dict.py

@@ -725,3 +725,53 @@ def test_values_with_pointer(self) -> None:
         v.sort()
         self.assertTrue(v, [1, 2, 3])
         self.assertEqual(b, b.dict())
+
+
+class base_dict_update_keywords_test_case(unittest.TestCase):
+    def test_update_with_no_arguments(self) -> None:
+        for value in (BaseDict(a=1), BaseDict({"a": 1})):
+            with self.subTest(wrapped=value._dict is not None):
+                self.assertIsNone(value.update())
+                self.assertEqual(value, {"a": 1})
+
+    def test_update_with_keywords_and_positional_source(self) -> None:
+        for value in (BaseDict(a=1), BaseDict({"a": 1})):
+            with self.subTest(wrapped=value._dict is not None):
+                value.update(b=2)
+                self.assertEqual(value, {"a": 1, "b": 2})
+                value.update({"a": 3}, a=4, c=5)
+                self.assertEqual(value, {"a": 4, "b": 2, "c": 5})
+
+    def test_update_keywords_unwrap_nested_base_dict(self) -> None:
+        source = {"a": 1}
+        nested = BaseDict(source)
+        for value in (BaseDict(), BaseDict({})):
+            with self.subTest(wrapped=value._dict is not None):
+                value.update(nested=nested)
+                self.assertIs(value["nested"], source)
+
+    def test_frozen_update_with_keywords_or_no_arguments(self) -> None:
+        for value in (BaseDict(a=1), BaseDict({"a": 1})):
+            value.freeze()
+            with self.subTest(wrapped=value._dict is not None):
+                with self.assertRaises(TypeError):
+                    value.update(a=2)
+                with self.assertRaises(TypeError):
+                    value.update()
+                self.assertEqual(value, {"a": 1})
+
+    def test_update_treats_reserved_keyword_names_as_keys(self) -> None:
+        for wrapped in (False, True):
+            for positional in (False, True):
+                for keyword in ("self", "other"):
+                    with self.subTest(
+                        wrapped=wrapped, positional=positional, keyword=keyword
+                    ):
+                        original = {"a": 1}
+                        value = BaseDict(original) if wrapped else BaseDict(a=1)
+                        args = ({"b": 2},) if positional else ()
+                        kwargs = {keyword: 3}
+                        expected = {"a": 1}
+                        expected.update(*args, **kwargs)
+                        self.assertIsNone(value.update(*args, **kwargs))
+                        self.assertEqual(value, expected)

tests/dicts/keypath/test_keypath_dict.py

@@ -68,6 +68,26 @@ def test_update_with_dict_with_separator_in_keys(self) -> None:
         with self.assertRaises(ValueError):
             b.update(d2)
 
+    def test_update_with_keywords(self) -> None:
+        b = KeypathDict({"a": 1})
+        b.update(b=2)
+        self.assertEqual(b, {"a": 1, "b": 2})
+        b.update({"a": 3}, a=4, c=5)
+        self.assertEqual(b, {"a": 4, "b": 2, "c": 5})
+
+    def test_update_with_no_arguments(self) -> None:
+        b = KeypathDict({"a": 1})
+        b.update()
+        self.assertEqual(b, {"a": 1})
+
+    def test_update_with_keywords_with_separator_in_keys(self) -> None:
+        b = KeypathDict({"a": 1})
+        with self.assertRaises(ValueError):
+            b.update(**{"a.x": 4})
+        with self.assertRaises(ValueError):
+            b.update(x={"a.y": 5})
+        self.assertEqual(b, {"a": 1})
+
     def test_update_with_dict_without_separator_in_keys(self) -> None:
         d1 = {
             "a": 1,

tests/dicts/test_benedict.py

@@ -2449,6 +2449,17 @@ def test_unflatten(self) -> None:
         self.assertEqual(type(b), type(u))
         self.assertTrue(isinstance(u, benedict))
 
+    def test_update_with_keywords(self) -> None:
+        d = {"a": 1}
+        b = benedict(d)
+        b.update(b=2)
+        b.update({"c": 3}, d={"e": 4})
+        b.update()
+        self.assertEqual(d, {"a": 1, "b": 2, "c": 3, "d": {"e": 4}})
+        self.assertEqual(b["d.e"], 4)
+        with self.assertRaises(ValueError):
+            b.update(**{"x.y": 5})
+
     def test_unique(self) -> None:
         d = {
             "a": {