fixed another edge case with use of enum in nested dicts

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -41,23 +41,32 @@ def __setitem__(self, key, value):                                          # Ch
     def __enter__(self): return self
     def __exit__ (self, type, value, traceback): pass
 
-    def json(self):
-        from osbot_utils.type_safe.Type_Safe import Type_Safe
+    # todo: this method needs to be refactored into smaller parts, it is getting to complex:
+    #         the use of the inner method serialize_value
+    #         the circular dependency on Type_Safe
+    #         the inner for loops to handle nested dictionaries
+    #         the enum edges cases (like the nested dictionaries case)
+    #         .
+    #         good news is that we have tons of tests and edge cases detection (so we should be able to do this
+    #         refactoring with no side effects
+    def json(self):                                                                     # Recursively serialize values, handling nested structures
+        from osbot_utils.type_safe.Type_Safe import Type_Safe                           # needed here due to circular dependencies
 
         def serialize_value(v):
-            """Recursively serialize values, handling nested structures"""
             if isinstance(v, Type_Safe):
                 return v.json()
             elif isinstance(v, Type_Safe__Primitive):
                 return v.__to_primitive__()
             elif isinstance(v, type):
                 return class_full_name(v)
             elif isinstance(v, dict):
-                # Recursively handle nested dictionaries
-                return {k2: serialize_value(v2) for k2, v2 in v.items()}
+                return {                                                                            # Recursively handle nested dictionaries (with enum support)
+                            (k2.value if isinstance(k2, Enum) else k2): serialize_value(v2)
+                            for k2, v2 in v.items()
+                        }
+                #return {k2: serialize_value(v2) for k2, v2 in v.items()}                            # Recursively handle nested dictionaries
             elif isinstance(v, (list, tuple, set, frozenset)):
-                # Recursively handle sequences
-                serialized = [serialize_value(item) for item in v]
+                serialized = [serialize_value(item) for item in v]                                  # Recursively handle sequences
                 if isinstance(v, list):
                     return serialized
                 elif isinstance(v, tuple):
@@ -95,4 +104,4 @@ def obj(self) -> __:
         return dict_to_obj(self.json())
 
     def values(self) -> Type_Safe__List:
-        return Type_Safe__List(self.expected_value_type, super().values())
+        return Type_Safe__List(self.expected_value_type, super().values())

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

@@ -6,8 +6,6 @@
 
 class test_Type_Safe__Dict__bugs(TestCase):
 
-
-
     def test__bug__type_safe_list_with_dict_any_type__and__error_message_is_confusing(self):   # Document bug where Dict[str, any] fails in List ,and the error message doesn't mention that Any works
 
         class Schema__Order__Bug(Type_Safe):

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

@@ -1,3 +1,5 @@
+import json
+import re
 import pytest
 from enum                                                                           import Enum
 from unittest                                                                       import TestCase
@@ -380,4 +382,79 @@ class An_Class(Type_Safe):
         assert An_Class(an_dict={'A': 42}).json() ==   { 'an_dict': {  'A': 42}}        # FIXED
         assert An_Class.from_json(An_Class(an_dict={'A': 42}).json()).obj() == __(an_dict=__(A=42))            # FIXED
         assert An_Class.from_json({ 'an_dict': {  An_Enum.A: 42}}   ).obj() == __(an_dict=__(A=42))            #
-        assert An_Class.from_json({ 'an_dict': {  'A'      : 42}}   ).obj() == __(an_dict=__(A=42))            #
+        assert An_Class.from_json({ 'an_dict': {  'A'      : 42}}   ).obj() == __(an_dict=__(A=42))            #
+
+    def test__regression__nested_dict_enum_keys__obj_vs_json_inconsistency(self):
+        """
+        BUG: .obj() and .json() are inconsistent for nested Dict with Enum keys.
+        .json() uses enum.value, .obj() uses transformed enum.name
+        """
+        class Status(str, Enum):
+            ACTIVE   = 'active'
+            INACTIVE = 'inactive'
+
+        class Container(Type_Safe):
+            nested: Dict[str, Dict[Status, int]]
+
+        container = Container(nested={'key': {Status.ACTIVE: 100}})
+
+        # .json() uses enum VALUE
+        assert container.json() == {'nested': {'key': {'active': 100}}}
+
+        # BUG: .obj() should also use 'active' but uses 'Status_ACTIVE'
+        #assert container.obj() == __(nested=__(key=__(Status_ACTIVE=100)))  # BUG Current behavior
+        #assert container.obj() != __(nested=__(key=__(active=100)))         # BUG Expected behavior
+        assert container.obj() == __(nested=__(key=__(active=100)))          # FIXED
+
+        # assert container.json() == {'nested': {'key': {Status.ACTIVE: 100}}}                                  # BUG
+        # error_message = ("assert {'nested': {'key': {<Status.ACTIVE: 'active'>: 100}}} == {}\n  \n  "
+        #                  "Left contains 1 more item:\n  "
+        #                  "{'nested': {'key': {<Status.ACTIVE: 'active'>: 100}}}\n  \n  "
+        #                  "Full diff:\n  - {}\n  + {\n  +     'nested': {\n  +         'key': "
+        #                  "{\n  +             <Status.ACTIVE: 'active'>: 100,\n  +         },\n  +     "
+        #                  "},\n  + }")                                                                          # BUG
+        assert container.json() == {'nested': {'key': {Status.ACTIVE: 100}}}                # this works due to auto conversion of enum into it's string value
+        assert container.json() == {'nested': {'key': {'active': 100}}}                     # FIXED: this is what we wanted to happen
+        error_message = ("assert {'nested': {'key': {'active': 100}}} == {}\n  \n  "
+                         "Left contains 1 more item:\n  "
+                         "{'nested': {'key': {'active': 100}}}\n  \n  "                     # FIXED: now we get the 'active' string (instead of the Enum representation)
+                         "Full diff:\n  - {}\n  + {\n  +     'nested': "
+                         "{\n  +         'key': {\n  +             "
+                         "'active': 100,\n  +         },\n  +     },\n  + }")
+        with pytest.raises(AssertionError, match=re.escape(error_message)):
+            assert container.json() == {}                                                   # FIXED this is the error message we should get
+
+        error_message_2 = 'assert __(nested=__(key=__(active=100))) == __()\n '
+        with pytest.raises(AssertionError, match=re.escape(error_message_2)):
+            assert container.obj() == __()
+
+        # couple more edge cases tests
+        json_str = json.dumps(container.json())
+        assert json_str == '{"nested": {"key": {"active": 100}}}'
+        assert json.loads(json_str) == {'nested': {'key': {'active': 100}}}
+
+        container2 = Container(nested={'key': {Status.ACTIVE: 100, Status.INACTIVE: 50}})
+        assert container2.json() == {'nested': {'key': {'active': 100, 'inactive': 50}}}
+        assert container2.obj() == __(nested=__(key=__(active=100, inactive=50)))
+
+        # Test round-trip consistency
+        container3 = Container.from_json(container.json())
+        assert container3.json() == container.json()
+        assert container3.obj()  == container.obj()
+
+    def test__regression__simple_dict_enum_keys__now__works_correctly(self):
+
+        class Status(str, Enum):
+            ACTIVE   = 'active'
+            INACTIVE = 'inactive'
+
+        class SimpleContainer(Type_Safe):
+            data: Dict[Status, int]
+
+        simple = SimpleContainer(data={Status.ACTIVE: 100})
+
+        # Single-level Dict works correctly - uses enum value
+        assert simple.json() == {'data': {'active': 100}}  # ✓ Correct
+
+        # And it's JSON-serializable
+        assert json.dumps(simple.json()) == '{"data": {"active": 100}}'  # ✓ Works