Add keyattr_dynamic property (False by default). #261 (#266)

* Add `AttributeError` message.

* Add `keyattr_dynamic` property (default `False`).

* Update README.md

Author: fabiocaccamo

README.md

@@ -90,25 +90,40 @@ page = params.get_int("page", 1)
 It is possible to get/set items using **keys as attributes** (dotted notation).
 
 ```python
-d = benedict()
+d = benedict(keyattr_dynamic=True) # default False
 d.profile.firstname = "Fabio"
 d.profile.lastname = "Caccamo"
 print(d) # -> { "profile":{ "firstname":"Fabio", "lastname":"Caccamo" } }
 ```
 
+By default, if the `keyattr_dynamic` is not explicitly set to `True`, this functionality works for get/set only already existing items.
+
 #### Disable keyattr functionality
-You can disable the keyattr functionality passing `keyattr_enabled=False` in the constructor.
+You can disable the keyattr functionality passing `keyattr_enabled=False` option in the constructor.
 
 ```python
-d = benedict(existing_dict, keyattr_enabled=False)
+d = benedict(existing_dict, keyattr_enabled=False) # default True
 ```
 
-You can disable the keyattr functionality using the `getter/setter` property.
+or using the `getter/setter` property.
 
 ```python
 d.keyattr_enabled = False
 ```
 
+#### Dynamic keyattr functionality
+You can enable the dynamic attributes access functionality passing `keyattr_dynamic=True` in the constructor.
+
+```python
+d = benedict(existing_dict, keyattr_dynamic=True) # default False
+```
+
+or using the `getter/setter` property.
+
+```python
+d.keyattr_dynamic = True
+```
+
 > **Warning** - even if this feature is very useful, it has some obvious limitations: it works only for string keys that are *unprotected* (not starting with an `_`) and that don't clash with the currently supported methods names.
 
 ### Keylist
@@ -173,13 +188,13 @@ d.keypath_separator = "/"
 ```
 
 #### Disable keypath functionality
-You can disable the keypath functionality passing `keypath_separator=None` in the constructor.
+You can disable the keypath functionality passing `keypath_separator=None` option in the constructor.
 
 ```python
 d = benedict(existing_dict, keypath_separator=None)
 ```
 
-You can disable the keypath functionality using the `getter/setter` property.
+or using the `getter/setter` property.
 
 ```python
 d.keypath_separator = None

benedict/dicts/__init__.py

@@ -47,6 +47,7 @@ def __init__(self, *args, **kwargs):
         if len(args) == 1 and isinstance(args[0], benedict):
             obj = args[0]
             kwargs.setdefault("keyattr_enabled", obj.keyattr_enabled)
+            kwargs.setdefault("keyattr_dynamic", obj.keyattr_dynamic)
             kwargs.setdefault("keypath_separator", obj.keypath_separator)
             super().__init__(obj.dict(), **kwargs)
             return
@@ -56,6 +57,7 @@ def __deepcopy__(self, memo):
         obj_type = type(self)
         obj = obj_type(
             keyattr_enabled=self._keyattr_enabled,
+            keyattr_dynamic=self._keyattr_dynamic,
             keypath_separator=self._keypath_separator,
         )
         for key, value in self.items():
@@ -78,6 +80,7 @@ def _cast(self, value):
             return obj_type(
                 value,
                 keyattr_enabled=self._keyattr_enabled,
+                keyattr_dynamic=self._keyattr_dynamic,
                 keypath_separator=self._keypath_separator,
                 check_keys=False,
             )

benedict/dicts/keyattr/keyattr_dict.py

@@ -3,9 +3,11 @@
 
 class KeyattrDict(BaseDict):
     _keyattr_enabled = None
+    _keyattr_dynamic = None
 
     def __init__(self, *args, **kwargs):
         self._keyattr_enabled = kwargs.pop("keyattr_enabled", True)
+        self._keyattr_dynamic = kwargs.pop("keyattr_dynamic", False)
         super().__init__(*args, **kwargs)
 
     @property
@@ -16,35 +18,45 @@ def keyattr_enabled(self):
     def keyattr_enabled(self, value):
         self._keyattr_enabled = value
 
+    @property
+    def keyattr_dynamic(self):
+        return self._keyattr_dynamic
+
+    @keyattr_dynamic.setter
+    def keyattr_dynamic(self, value):
+        self._keyattr_dynamic = value
+
     def __getattr__(self, attr):
+        attr_message = f"{self.__class__.__name__!r} object has no attribute {attr!r}"
         if not self._keyattr_enabled:
-            raise AttributeError
-        # return super().__getattr__(attr)
+            raise AttributeError(attr_message)
         try:
             return self.__getitem__(attr)
         except KeyError:
             if attr.startswith("_"):
-                raise AttributeError(
-                    f"{self.__class__.__name__!r} object has no attribute {attr!r}"
-                ) from None
+                raise AttributeError(attr_message) from None
+            if not self._keyattr_dynamic:
+                raise AttributeError(attr_message) from None
             self.__setitem__(attr, {})
             return self.__getitem__(attr)
 
     def __setattr__(self, attr, value):
+        attr_message = f"{self.__class__.__name__!r} object has no attribute {attr!r}"
         if attr in self:
             # set existing key
             if not self._keyattr_enabled:
-                raise AttributeError
+                raise AttributeError(attr_message)
             self.__setitem__(attr, value)
         elif hasattr(self.__class__, attr):
             # set existing attr
             super().__setattr__(attr, value)
         else:
             # set new key
             if not self._keyattr_enabled:
-                raise AttributeError
+                raise AttributeError(attr_message)
             self.__setitem__(attr, value)
 
     def __setstate__(self, state):
         super().__setstate__(state)
         self._keyattr_enabled = state["_keyattr_enabled"]
+        self._keyattr_dynamic = state["_keyattr_dynamic"]

tests/dicts/test_benedict_keyattr.py

@@ -14,7 +14,23 @@ def test_getitem(self):
                 },
             },
         }
-        b = benedict(d, keyattr_enabled=True)
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=True)
+        self.assertEqual(b.a.b.c, "ok")
+        self.assertEqual(b.a.b.d[-1], 3)
+        self.assertEqual(b.a.b.e[0].f, 4)
+        self.assertEqual(b.a.b.e[-1].g[0], 5)
+
+    def test_getitem_not_dynamic(self):
+        d = {
+            "a": {
+                "b": {
+                    "c": "ok",
+                    "d": [0, 1, 2, 3],
+                    "e": [{"f": 4}, {"g": [5]}],
+                },
+            },
+        }
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=True)
         self.assertEqual(b.a.b.c, "ok")
         self.assertEqual(b.a.b.d[-1], 3)
         self.assertEqual(b.a.b.e[0].f, 4)
@@ -24,9 +40,17 @@ def test_getitem_with_non_existing_key(self):
         d = {
             "a": "ok",
         }
-        b = benedict(d, keyattr_enabled=True)
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=True)
         self.assertEqual(b.b, {})
 
+    def test_getitem_with_non_existing_key_not_dynamic(self):
+        d = {
+            "a": "ok",
+        }
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=False)
+        with self.assertRaises(AttributeError):
+            _ = b.b
+
     def test_getitem_with_non_existing_protected_item(self):
         d = {
             "a": {
@@ -42,6 +66,21 @@ def test_getitem_with_non_existing_protected_item(self):
         with self.assertRaises(AttributeError):
             b.a.b.__test__()
 
+    def test_getitem_with_non_existing_protected_item_not_dynamic(self):
+        d = {
+            "a": {
+                "b": {
+                    "c": "ok",
+                },
+            },
+        }
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=False)
+        self.assertEqual(b.a.b.c, "ok")
+        with self.assertRaises(AttributeError):
+            b.__test__()
+        with self.assertRaises(AttributeError):
+            b.a.b.__test__()
+
     def test_getitem_with_keyattr_disabled(self):
         d = {
             "a": "ok",
@@ -50,6 +89,14 @@ def test_getitem_with_keyattr_disabled(self):
         with self.assertRaises(AttributeError):
             _ = b.a
 
+    def test_getitem_with_keyattr_disabled_not_dynamic(self):
+        d = {
+            "a": "ok",
+        }
+        b = benedict(d, keyattr_enabled=False)
+        with self.assertRaises(AttributeError):
+            _ = b.a
+
     def test_setitem(self):
         d = {
             "a": {
@@ -60,7 +107,7 @@ def test_setitem(self):
                 },
             },
         }
-        b = benedict(d, keyattr_enabled=True)
+        b = benedict(d, keyattr_enabled=True, keyattr_dynamic=True)
         b.a.b.c = "ok"
         self.assertEqual(b.a.b.c, "ok")
         b.a.b.d[-1] = 4
@@ -79,25 +126,38 @@ def test_setitem_with_keyattr_disabled(self):
             b.a = 2
         with self.assertRaises(AttributeError):
             b.b = 3
+        with self.assertRaises(AttributeError):
+            b.c.d = 3
+
+    def test_setitem_with_keyattr_not_dynamic(self):
+        d = {
+            "a": 1,
+        }
+        b = benedict(d, keyattr_dynamic=False)
+        b.a = 2
+        b.b = 3
+        with self.assertRaises(AttributeError):
+            b.c.d = 3
 
     def test_setitem_with_non_existing_key(self):
-        b = benedict(keyattr_enabled=True)
+        b = benedict(keyattr_enabled=True, keyattr_dynamic=True)
+        b.a = "ok"
+        self.assertEqual(b.a, "ok")
+
+    def test_setitem_with_non_existing_key_not_dynamic(self):
+        b = benedict(keyattr_enabled=True, keyattr_dynamic=False)
         b.a = "ok"
         self.assertEqual(b.a, "ok")
 
     def test_setitem_with_non_existing_nested_keys(self):
-        b = benedict(keyattr_enabled=True)
+        b = benedict(keyattr_enabled=True, keyattr_dynamic=True)
         b.a.b.c = "ok"
-        self.assertEqual(
-            b,
-            {
-                "a": {
-                    "b": {
-                        "c": "ok",
-                    },
-                },
-            },
-        )
+        self.assertEqual(b.a.b.c, "ok")
+
+    def test_setitem_with_non_existing_nested_keys_not_dynamic(self):
+        b = benedict(keyattr_enabled=True, keyattr_dynamic=False)
+        with self.assertRaises(AttributeError):
+            b.a.b.c = "ok"
 
     def test_setitem_with_conflicting_key(self):
         d = {
@@ -111,15 +171,48 @@ def test_keyattr_enabled_default(self):
         d = benedict()
         self.assertTrue(d.keyattr_enabled)
 
+    def test_keyattr_dynamic_default(self):
+        d = benedict()
+        self.assertFalse(d.keyattr_dynamic)
+
     def test_keyattr_enabled_from_constructor(self):
         d = benedict(keyattr_enabled=True)
         self.assertTrue(d.keyattr_enabled)
         d = benedict(keyattr_enabled=False)
         self.assertFalse(d.keyattr_enabled)
 
+    def test_keyattr_dynamic_from_constructor(self):
+        d = benedict(keyattr_dynamic=True)
+        self.assertTrue(d.keyattr_dynamic)
+        d = benedict(keyattr_dynamic=False)
+        self.assertFalse(d.keyattr_dynamic)
+
     def test_keyattr_enabled_getter_setter(self):
         d = benedict()
         d.keyattr_enabled = False
         self.assertFalse(d.keyattr_enabled)
         d.keyattr_enabled = True
         self.assertTrue(d.keyattr_enabled)
+
+    def test_keyattr_dynamic_getter_setter(self):
+        d = benedict()
+        d.keyattr_dynamic = False
+        self.assertFalse(d.keyattr_dynamic)
+        d.keyattr_dynamic = True
+        self.assertTrue(d.keyattr_dynamic)
+
+    def test_keyattr_enabled_inheritance_on_casting(self):
+        d = benedict(keyattr_enabled=True)
+        c = benedict(d)
+        self.assertTrue(c.keyattr_enabled)
+        d = benedict(keyattr_enabled=False)
+        c = benedict(d)
+        self.assertFalse(c.keyattr_enabled)
+
+    def test_keyattr_dynamic_inheritance_on_casting(self):
+        d = benedict(keyattr_dynamic=True)
+        c = benedict(d)
+        self.assertTrue(c.keyattr_dynamic)
+        d = benedict(keyattr_dynamic=False)
+        c = benedict(d)
+        self.assertFalse(c.keyattr_dynamic)