added more fixes for some edge cases on the serialisation of Type_Safe__Dict , __List, __Set and __List

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -3,7 +3,7 @@
 from osbot_utils.type_safe.Type_Safe__Base                            import Type_Safe__Base
 from osbot_utils.type_safe.Type_Safe__Primitive                       import Type_Safe__Primitive
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
-from osbot_utils.utils.Objects                                        import class_full_name
+from osbot_utils.utils.Objects import class_full_name, serialize_to_dict
 
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
@@ -54,7 +54,7 @@ def serialize_value(v):
             elif isinstance(v, dict):
                 # Recursively handle nested dictionaries
                 return {k2: serialize_value(v2) for k2, v2 in v.items()}
-            elif isinstance(v, (list, tuple, set)):
+            elif isinstance(v, (list, tuple, set, frozenset)):
                 # Recursively handle sequences
                 serialized = [serialize_value(item) for item in v]
                 if isinstance(v, list):
@@ -64,7 +64,8 @@ def serialize_value(v):
                 else:  # set
                     return set(serialized)
             else:
-                return v
+                return serialize_to_dict(v)             # Use serialize_to_dict for unknown types (so that we don't return a non json object)
+
 
         result = {}
         for key, value in self.items():

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py

@@ -1,6 +1,6 @@
 from enum                                       import Enum
 from typing                                     import Type
-from osbot_utils.utils.Objects                  import class_full_name
+from osbot_utils.utils.Objects import class_full_name, serialize_to_dict
 from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 from osbot_utils.type_safe.Type_Safe__Base      import Type_Safe__Base, type_str
 
@@ -82,12 +82,14 @@ def json(self): # Convert the list to a JSON-serializable format.
                 result.append(item.json())
             elif isinstance(item, Type_Safe__Primitive):
                 result.append(item.__to_primitive__())
-            elif isinstance(item, (list, tuple)):
-                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
+            elif isinstance(item, (list, tuple, frozenset)):
+                result.append([x.json() if isinstance(x, Type_Safe) else serialize_to_dict(x) for x in item])
+                #result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])      # BUG here
             elif isinstance(item, dict):
-                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
+                result.append(serialize_to_dict(item))          # leverage serialize_to_dict since that method already knows how to handle
+                #result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
             elif isinstance(item, type):
                 result.append(class_full_name(item))
             else:
-                result.append(item)
+                result.append(serialize_to_dict(item))          # also Use serialize_to_dict for unknown types (so that we don't return a non json object)
         return result

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py

@@ -1,4 +1,4 @@
-from osbot_utils.utils.Objects                  import class_full_name
+from osbot_utils.utils.Objects import class_full_name, serialize_to_dict
 from osbot_utils.type_safe.Type_Safe__Base      import Type_Safe__Base, type_str
 from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
@@ -52,14 +52,14 @@ def json(self):
                 result.append(item.json())
             elif isinstance(item, Type_Safe__Primitive):
                 result.append(item.__to_primitive__())
-            elif isinstance(item, (list, tuple, set)):
-                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
-            elif isinstance(item, dict):
-                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
+            elif isinstance(item, (list, tuple, set, frozenset)):
+                result.append([x.json() if isinstance(x, Type_Safe) else serialize_to_dict(x) for x in item])
+            # elif isinstance(item, dict):
+            #     result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
             elif isinstance(item, type):
                 result.append(class_full_name(item))
             else:
-                result.append(item)
+                result.append(serialize_to_dict(item))          # Use serialize_to_dict for unknown types (so that we don't return a non json object)
         return result
 
     def __eq__(self, other):                                        # todo: see if this is needed

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -1,4 +1,4 @@
-from osbot_utils.utils.Objects              import class_full_name
+from osbot_utils.utils.Objects import class_full_name, serialize_to_dict
 from osbot_utils.type_safe.Type_Safe__Base  import Type_Safe__Base, type_str
 
 class Type_Safe__Tuple(Type_Safe__Base, tuple):
@@ -66,12 +66,12 @@ def json(self):
                 result.append(item.json())
             elif isinstance(item, Type_Safe__Primitive):
                 result.append(item.__to_primitive__())  # Convert primitives to base types
-            elif isinstance(item, (list, tuple)):
-                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
+            elif isinstance(item, (list, tuple, frozenset)):
+                result.append([x.json() if isinstance(x, Type_Safe) else serialize_to_dict(x) for x in item])
             elif isinstance(item, dict):
-                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
+                result.append(serialize_to_dict(item))
             elif isinstance(item, type):
                 result.append(class_full_name(item))
             else:
-                result.append(item)
+                result.append(serialize_to_dict(item))          # Use serialize_to_dict for unknown types (so that we don't return a non json object)
         return result

osbot_utils/utils/Objects.py

@@ -275,7 +275,7 @@ def serialize_to_dict(obj):
     elif isinstance(obj, Enum):
         if isinstance(obj.value, (str, int, float, bool, type(None))):                          # Check if the enum value is directly serializable
             return obj.value
-        elif isinstance(obj.value, (list, tuple, dict, set)):                                        # Recursively serialize complex values
+        elif isinstance(obj.value, (list, tuple, dict, set, frozenset)):                                        # Recursively serialize complex values
             return serialize_to_dict(obj.value)
         else:
             return obj.name                                                                     # Fallback to name for non-serializable values
@@ -285,7 +285,7 @@ def serialize_to_dict(obj):
         return f"{obj.__module__}.{obj.__name__}"                                   # save the full type name
     elif isinstance(obj, (list, tuple, List)):                                     # Added tuple here
         return [serialize_to_dict(item) for item in obj]
-    elif isinstance(obj, set):
+    elif isinstance(obj, (set, frozenset)):
         return [serialize_to_dict(item) for item in obj]
     elif isinstance(obj, dict):
         serialized_dict = {}                                                        # todo: refactor to separate method

tests/unit/type_safe/test_Type_Safe.py

@@ -13,7 +13,7 @@
 from osbot_utils.type_safe.primitives.domains.identifiers.Guid                      import Guid
 from osbot_utils.type_safe.primitives.domains.identifiers.Random_Guid               import Random_Guid
 from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
-from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict import Type_Safe__Dict
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict               import Type_Safe__Dict
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List               import Type_Safe__List
 from osbot_utils.testing.Catch                                                      import Catch
 from osbot_utils.testing.Stdout                                                     import Stdout

tests/unit/type_safe/type_safe_core/_bugs/test_Type_Safe__List__bugs.py

@@ -1,7 +1,6 @@
 from typing                                                           import List
 from unittest                                                         import TestCase
 from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
-from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
 
 
 class test_Type_Safe__List__bugs(TestCase):
@@ -19,28 +18,3 @@ def invalid_func(x: str) -> int:                    # Invalid callable (wrong si
             return len(x)
 
         an_class.an_list__callable.append(invalid_func)     # BUG doesn't raise  (i.e. at the moment we are not detecting the callable signature and return type)
-
-    def test__bug__json_with_nested_dicts(self):
-        class TestType(Type_Safe):
-            value: str
-
-            def __init__(self, value):
-                self.value = value
-
-        dict_list = Type_Safe__List(dict)
-        dict_list.append({"simple": "value"})
-        dict_list.append({
-            "normal": 42,
-            "safe": TestType("test"),
-            "nested": {"deep": TestType("deep")}
-        })
-
-        expected = [
-            {"simple": "value"},
-            {
-                "normal": 42,
-                "safe": {"value": "test"},
-                "nested": {"deep": {"value": "deep"}}
-            }
-        ]
-        assert dict_list.json() != expected

tests/unit/type_safe/type_safe_core/_regression/test_Type_Safe__List__regression.py

@@ -231,4 +231,30 @@ class An_Class(Type_Safe):
         # with pytest.raises(AttributeError, match = "Type_Safe__List' object has no attribute 'json'"):
         #     assert an_class.an_list.json()
 
-        assert an_class.an_list.json() == [{'an_list': [], 'an_str': ''}]
+        assert an_class.an_list.json() == [{'an_list': [], 'an_str': ''}]
+
+    def test__regression__json_with_nested_dicts(self):
+        class TestType(Type_Safe):
+            value: str
+
+            def __init__(self, value):
+                self.value = value
+
+        dict_list = Type_Safe__List(dict)
+        dict_list.append({"simple": "value"})
+        dict_list.append({
+            "normal": 42,
+            "safe": TestType("test"),
+            "nested": {"deep": TestType("deep")}
+        })
+
+        expected = [
+            {"simple": "value"},
+            {
+                "normal": 42,
+                "safe": {"value": "test"},
+                "nested": {"deep": {"value": "deep"}}
+            }
+        ]
+        #assert dict_list.json() != expected         # BUG
+        assert dict_list.json() == expected         # FIXED

tests/unit/type_safe/type_safe_core/collections/test_Type_Safe__Dict.py

@@ -1,8 +1,11 @@
 import re
+import socket
 import sys
+import threading
 import pytest
 from unittest                                                         import TestCase
 from typing                                                           import Dict, Union, Optional, Any, Callable, List, Tuple
+from osbot_utils.testing.__                                           import __
 from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id      import Obj_Id
 from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
 from osbot_utils.type_safe.Type_Safe__Primitive                       import Type_Safe__Primitive
@@ -536,3 +539,92 @@ class An_Class(Type_Safe):
 
 
 
+    def test_json__with_unserializable_values(self):                                            # Test that Type_Safe__Dict.json() handles unserializable values gracefully
+        config            = Type_Safe__Dict(expected_key_type=str, expected_value_type=object)  # Create dict with mixed serializable and unserializable values
+        config['host'    ] = 'localhost'
+        config['port'    ] = 8080
+        config['active'  ] = True
+        config['_lock'   ] = threading.RLock()  # Unserializable
+        config['_complex'] = 3 + 4j  # Unserializable
+        config['_socket' ] = socket.socket()  # Unserializable
+
+        result = config.json()
+
+        # Serializable values preserved
+        assert result['host'] == 'localhost'
+        assert result['port'] == 8080
+        assert result['active'] is True
+
+        # Unserializable values become None
+        assert result['_lock'] is None
+        assert result['_complex'] is None
+        assert result['_socket'] is None
+
+        config['_socket'].close()  # Clean up
+
+    def test_json__with_nested_unserializable_in_dict_values(self):             # Test Type_Safe__Dict with nested structures containing unserializable objects"""
+
+        settings = Type_Safe__Dict(expected_key_type=str, expected_value_type=object)
+        settings['database'] = {
+            'host': 'db.example.com',
+            'port': 5432,
+            '_lock': threading.RLock()  # Nested unserializable
+        }
+        settings['cache'] = {
+            'enabled': True,
+            'ttl': 300,
+            '_connection': 3 + 4j  # Nested unserializable
+        }
+
+        result = settings.json()
+
+        # Check nested structure is preserved with None for unserializable
+        assert result['database']['host'] == 'db.example.com'
+        assert result['database']['port'] == 5432
+        assert result['database']['_lock'] is None
+
+        assert result['cache']['enabled'] is True
+        assert result['cache']['ttl'] == 300
+        assert result['cache']['_connection'] is None
+
+    def test_json__with_unserializable_in_list_values(self):                    # Test Type_Safe__Dict with list values containing unserializable objects
+
+        data = Type_Safe__Dict(expected_key_type=str, expected_value_type=object)
+        data['items'] = [
+            'valid_string',
+            123,
+            threading.RLock(),  # Unserializable in list
+            {'key': 'value'},
+            3 + 4j  # Another unserializable
+        ]
+
+        result = data.json()
+
+        assert result['items'][0] == 'valid_string'
+        assert result['items'][1] == 123
+        assert result['items'][2] is None  # RLock becomes None
+        assert result['items'][3] == {'key': 'value'}
+        assert result['items'][4] is None  # Complex number becomes None
+
+    def test_obj__with_unserializable_values(self):                             # Test that Type_Safe__Dict.obj() works with unserializable values
+
+        config = Type_Safe__Dict(expected_key_type=str, expected_value_type=object)
+        config['url'] = 'http://api.example.com'
+        config['timeout'] = 30
+        config['_lock'] = threading.RLock()
+
+        result = config.obj()
+
+        assert result == __( url     = 'http://api.example.com',
+                            timeout  = 30,
+                            _lock    = None)  # Unserializable becomes None
+
+    def test_json__with_nested_frozenset_in_dict(self):                                 # Test frozenset as dict value
+
+        data = Type_Safe__Dict(expected_key_type=str, expected_value_type=object)
+        data['tags'] = frozenset(['python', 'testing', 'type-safe'])
+
+        result = data.json()
+
+        # Should serialize frozenset to list
+        assert set(result['tags']) == {'python', 'testing', 'type-safe'}