Merge dev into main

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from typing                                                           import Type
 from osbot_utils.testing.__                                           import __
 from osbot_utils.type_safe.Type_Safe__Base                            import Type_Safe__Base
@@ -64,19 +65,19 @@ def serialize_value(v):
                 else:  # set
                     return set(serialized)
             else:
-                return serialize_to_dict(v)             # Use serialize_to_dict for unknown types (so that we don't return a non json object)
+                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():
-            # Handle Type objects as keys
-            if isinstance(key, (type, Type)):
+            if isinstance(key, (type, Type)):                           # Handle Type objects as keys
                 key = f"{key.__module__}.{key.__name__}"
+            elif isinstance(key, Enum):                                 #  Handle Enum keys
+                key = key.value
             elif isinstance(key, Type_Safe__Primitive):
                 key = key.__to_primitive__()
 
-            # Use recursive serialization for values
-            result[key] = serialize_value(value)
+            result[key] = serialize_value(value)                        # Use recursive serialization for values
 
         return result
 

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

@@ -7,6 +7,7 @@
 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/_bugs/test_Type_Safe__bugs.py

@@ -5,6 +5,7 @@
 
 class test_Type_Safe__bugs(TestCase):
 
+
     def test__bug__property_descriptor_handling__doesnt_enforce_type_safety(self):
 
         class Test_Class(Type_Safe):

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

@@ -1,4 +1,5 @@
 import pytest
+from enum                                                                           import Enum
 from unittest                                                                       import TestCase
 from typing                                                                         import Dict, Type, Set, Any, List
 from osbot_utils.testing.__helpers                                                  import obj
@@ -357,4 +358,26 @@ class An_Class_2(Type_Safe):
         an_class_2 = An_Class_2()
         an_class_2.all_paths = data                                                                     # FIXED:
         assert an_class_2.json()    == {"all_paths": data }                                             # confirm roundtrip with .json()
-        assert an_class_2.obj()     == __(all_paths = obj(data))                                        # confirm roundtrip with obj().
+        assert an_class_2.obj()     == __(all_paths = obj(data))                                        # confirm roundtrip with obj().
+
+    def test__regression__dict__json__enum__conversion(self):
+        class An_Enum(str, Enum):
+            A = 'A'
+            B = 'B'
+            C = 'C'
+
+        class An_Class(Type_Safe):
+            an_dict : Dict[An_Enum, int]
+
+        # assert An_Class()                .obj ()  == __(  an_dict = __())
+        # assert An_Class()                .json()  ==   { 'an_dict': {}  }
+        # assert An_Class(an_dict={'A': 42}).obj()  == __(  an_dict = __(An_Enum_A= 42))
+        # assert An_Class(an_dict={'A': 42}).json() ==   { 'an_dict': {  An_Enum.A: 42}}  # BUG: "An_Enum.A" is an Enum, and it should be a String (namely 'A')
+        # assert An_Class.from_json(An_Class(an_dict={'A': 42}).json()).obj() == __(an_dict=__(An_Enum_A=42))  # these 3 work
+        # assert An_Class.from_json({ 'an_dict': {  An_Enum.A: 42}}   ).obj() == __(an_dict=__(An_Enum_A=42))  # but .json() should NOT be this
+        # assert An_Class.from_json({ 'an_dict': {  'A'      : 42}}   ).obj() == __(an_dict=__(An_Enum_A=42))  # it should be this
+        assert An_Class(an_dict={'A': 42}).obj()  == __(  an_dict = __(A = 42))          # FIXED: An_Enum_A is now just A (which is a better result
+        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))            #