python-bunch 0.1.6__tar.gz → 0.1.7__tar.gz

{python_bunch-0.1.6/python_bunch.egg-info → python_bunch-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bunch
-Version: 0.1.6
+Version: 0.1.7
 Summary: A lightweight Python class that behaves like a dict but supports attribute-style access.
 Author-email: Omer Menashe <unspecified@mail.com>
 License: MIT

{python_bunch-0.1.6 → python_bunch-0.1.7}/bunch/bunch.py

@@ -66,5 +66,19 @@ class Bunch:
         return self.__dict__.items()
 
     @staticmethod
-    def from_dict(dictionary: dict) -> Any:
-        return Bunch(**dictionary)
+    def from_dict(dictionary: dict, recursive: bool = True) -> 'Bunch':
+        ret = Bunch()
+        if recursive:
+            for key, value in dictionary.items():
+                if isinstance(value, dict):
+                    ret[key] = Bunch.from_dict(value, recursive=True)
+                elif isinstance(value, list):
+                    ret[key] = [
+                        Bunch.from_dict(item, recursive=True) if isinstance(item, dict) else item
+                        for item in value
+                    ]
+                else:
+                    ret[key] = value
+        else:
+            ret.update(dictionary)
+        return ret

{python_bunch-0.1.6 → python_bunch-0.1.7}/bunch/immutable_bunch.py

@@ -1,6 +1,6 @@
 import json
 from typing import Any
-
+from bunch.bunch import Bunch
 
 class ImmutableBunchException(Exception):
     def __init__(self, message: str) -> None:
@@ -71,5 +71,19 @@ class ImmutableBunch:
         return self.__dict__.items()
 
     @staticmethod
-    def from_dict(dictionary: dict) -> Any:
-        return ImmutableBunch(**dictionary)
+    def from_dict(dictionary: dict, recursive: bool = True) -> 'ImmutableBunch':
+        ret = dict()
+        if recursive:
+            for key, value in dictionary.items():
+                if isinstance(value, dict):
+                    ret[key] = ImmutableBunch.from_dict(value, recursive=True)
+                elif isinstance(value, list):
+                    ret[key] = [
+                        ImmutableBunch.from_dict(item, recursive=True) if isinstance(item, dict) else item
+                        for item in value
+                    ]
+                else:
+                    ret[key] = value
+        else:
+            ret.update(dictionary)
+        return ImmutableBunch(**ret)

{python_bunch-0.1.6 → python_bunch-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-bunch"
-version = "0.1.6"
+version = "0.1.7"
 description = "A lightweight Python class that behaves like a dict but supports attribute-style access."
 readme = "README.md"
 requires-python = ">=3.7"

{python_bunch-0.1.6 → python_bunch-0.1.7/python_bunch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bunch
-Version: 0.1.6
+Version: 0.1.7
 Summary: A lightweight Python class that behaves like a dict but supports attribute-style access.
 Author-email: Omer Menashe <unspecified@mail.com>
 License: MIT

{python_bunch-0.1.6 → python_bunch-0.1.7}/tests/test_bunch.py

@@ -103,6 +103,51 @@ class TestBunch(unittest.TestCase):
         self.assertEqual(b.fruit, 'apple')
         self.assertEqual(b.color, 'red')
 
+    def test_from_dict_recursive_nested(self):
+        data = {
+            'user': {
+                'name': 'Alice',
+                'profile': {'age': 30, 'city': 'Paris'}
+            }
+        }
+        b = Bunch.from_dict(data, recursive=True)
+
+        self.assertIsInstance(b.user, Bunch)
+        self.assertIsInstance(b.user.profile, Bunch)
+        self.assertEqual(b.user.profile.city, 'Paris')
+
+    def test_from_dict_recursive_deeply_nested(self):
+        data = {'level1': {'level2': {'level3': {'value': 42}}}}
+        b = Bunch.from_dict(data, recursive=True)
+
+        self.assertEqual(b.level1.level2.level3.value, 42)
+        self.assertIsInstance(b.level1.level2, Bunch)
+        self.assertIsInstance(b.level1.level2.level3, Bunch)
+
+    def test_from_dict_with_list_of_dicts(self):
+        data = {
+            'users': [
+                {'name': 'Alice', 'age': 30},
+                {'name': 'Bob', 'age': 25}
+            ]
+        }
+        b = Bunch.from_dict(data, recursive=True)
+
+        self.assertIsInstance(b.users[0], Bunch)
+        self.assertEqual(b.users[0].name, 'Alice')
+        self.assertEqual(b.users[1].age, 25)
+
+    def test_from_dict_recursive_false(self):
+        data = {
+            'user': {
+                'name': 'Alice',
+                'profile': {'age': 30}
+            }
+        }
+        b = Bunch.from_dict(data, recursive=False)
+
+        self.assertIsInstance(b.user, dict)
+        self.assertEqual(b.user['profile']['age'], 30)
 
 if __name__ == '__main__':
     unittest.main()

{python_bunch-0.1.6 → python_bunch-0.1.7}/tests/test_immutable_bunch.py

@@ -109,6 +109,51 @@ class TestBunch(unittest.TestCase):
         self.assertEqual(ib.fruit, 'apple')
         self.assertEqual(ib.color, 'red')
 
+    def test_from_dict_recursive_nested(self):
+        data = {
+            'user': {
+                'name': 'Alice',
+                'profile': {'age': 30, 'city': 'Paris'}
+            }
+        }
+        b = ImmutableBunch.from_dict(data, recursive=True)
+
+        self.assertIsInstance(b.user, ImmutableBunch)
+        self.assertIsInstance(b.user.profile, ImmutableBunch)
+        self.assertEqual(b.user.profile.city, 'Paris')
+
+    def test_from_dict_recursive_deeply_nested(self):
+        data = {'level1': {'level2': {'level3': {'value': 42}}}}
+        b = ImmutableBunch.from_dict(data, recursive=True)
+
+        self.assertEqual(b.level1.level2.level3.value, 42)
+        self.assertIsInstance(b.level1.level2, ImmutableBunch)
+        self.assertIsInstance(b.level1.level2.level3, ImmutableBunch)
+
+    def test_from_dict_with_list_of_dicts(self):
+        data = {
+            'users': [
+                {'name': 'Alice', 'age': 30},
+                {'name': 'Bob', 'age': 25}
+            ]
+        }
+        b = ImmutableBunch.from_dict(data, recursive=True)
+
+        self.assertIsInstance(b.users[0], ImmutableBunch)
+        self.assertEqual(b.users[0].name, 'Alice')
+        self.assertEqual(b.users[1].age, 25)
+
+    def test_from_dict_recursive_false(self):
+        data = {
+            'user': {
+                'name': 'Alice',
+                'profile': {'age': 30}
+            }
+        }
+        b = ImmutableBunch.from_dict(data, recursive=False)
+
+        self.assertIsInstance(b.user, dict)
+        self.assertEqual(b.user['profile']['age'], 30)
 
 if __name__ == '__main__':
     unittest.main()