breaking change: fixed minor edge case with the roundtrip of enums that used tuple

Author: DinisCruz

osbot_utils/type_safe/primitives/domains/files/safe_str/Safe_Str__File__Path.py

@@ -4,6 +4,8 @@
 TYPE_SAFE_STR__FILE_PATH__REGEX      = re.compile(r'[^a-zA-Z0-9_\-./\\ ]')  # Allow alphanumerics, underscores, hyphens, dots, slashes, and spaces
 TYPE_SAFE_STR__FILE_PATH__MAX_LENGTH = 1024
 
+# todo:: this doesn't prevent path like "../../../etc/passwd" since those are valid paths
+#        look at what we can do there (in terms of adding methods for __add__ + __radd__ , having a different class with that type of protection (i.e. does not allow ../ paths)
 class Safe_Str__File__Path(Safe_Str):
     regex                      = TYPE_SAFE_STR__FILE_PATH__REGEX
     max_length                 = TYPE_SAFE_STR__FILE_PATH__MAX_LENGTH

osbot_utils/utils/Objects.py

@@ -273,12 +273,12 @@ def serialize_to_dict(obj):
     elif hasattr(obj, '__primitive_base__') and isinstance(obj, (str, int, float)):
         return obj.__primitive_base__(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, frozenset)):                                        # Recursively serialize complex values
-            return serialize_to_dict(obj.value)
+        if isinstance(obj.value, (str, int, float, bool, type(None))):                           # Check if the enum value is directly serializable
+            return obj.value                                                                     # todo: question could this cover all Type_Safe__Primitive classes?
+        # elif isinstance(obj.value, (list, tuple, dict, set, frozenset)):                                         # Recursively serialize complex values
+        #     return serialize_to_dict(obj.value)                                                # removed this since this was causing side effects in some roundtrips
         else:
-            return obj.name                                                                     # Fallback to name for non-serializable values
+            return obj.name                                                                      # it is better to use the enum name (which roundtrips ok)
     elif isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:                # todo: add support for objects like datetime
         return obj
     elif isinstance(obj, type):

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

@@ -1,11 +1,13 @@
+import re
 from typing                                                           import List
 from unittest                                                         import TestCase
+import pytest
+from osbot_utils.testing.__ import __
 from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
 
 
 class test_Type_Safe__List__bugs(TestCase):
 
-
     def test__bug__type_safe_list_with_callable(self):
         from typing import Callable
 

tests/unit/utils/test_Objects.py

@@ -750,29 +750,38 @@ class ComplexEnum(Enum):
         assert type(ComplexEnum.SET_VAL.value  ) is set
 
         # Should recursively serialize complex values
-        assert serialize_to_dict(ComplexEnum.LIST_VAL)        == [1, 2, 3]
-        assert serialize_to_dict(ComplexEnum.DICT_VAL)        == {'key': 'value', 'count': 42}
-        assert serialize_to_dict(ComplexEnum.TUPLE_VAL)       != ('a', 'b', 'c')                  # we can't convert to tuple since json doesn't support it
-        assert serialize_to_dict(ComplexEnum.TUPLE_VAL)       == ['a', 'b', 'c']                  # so the tuple becomes a list
-        assert sorted(serialize_to_dict(ComplexEnum.SET_VAL)) == sorted(['x', 'y', 'z'])          # same for set
+        assert serialize_to_dict(ComplexEnum.LIST_VAL )   == 'LIST_VAL'
+        assert serialize_to_dict(ComplexEnum.DICT_VAL )   == 'DICT_VAL'
+        assert serialize_to_dict(ComplexEnum.TUPLE_VAL)   == 'TUPLE_VAL'
+        assert serialize_to_dict(ComplexEnum.SET_VAL  )   == 'SET_VAL'
 
-        # Verify types
-        assert type(serialize_to_dict(ComplexEnum.LIST_VAL))  is list
-        assert type(serialize_to_dict(ComplexEnum.DICT_VAL))  is dict
-        assert type(serialize_to_dict(ComplexEnum.TUPLE_VAL)) is not tuple                        # we can't convert to tuple since json doesn't support it
-        assert type(serialize_to_dict(ComplexEnum.TUPLE_VAL)) is list                             # so the tuple becomes a list
-        assert type(serialize_to_dict(ComplexEnum.SET_VAL  )) is list                             # same for set
+
+    def test_from_json__Enum_tuple_support(self):
+        class An_Enum(tuple, Enum):
+            AB = ('a', 'b')
+            CD = ('c', 'd')
+
+        class An_Class(Type_Safe):
+            an_enum : An_Enum  # ← Stores the ENUM itself
+
+        # This is the real round-trip test:
+        an_class = An_Class(an_enum='AB')
+        assert an_class.json() == {'an_enum': 'AB'}  # ✅ Serializes to name
+
+        restored = An_Class.from_json(an_class.json())
+        assert restored.an_enum == An_Enum.AB  # ✅ Should deserialize back to enum
+        assert restored.an_enum == ('a', 'b')  # ✅ Enum value comparison works
 
     def test_enum_with_nested_complex_values(self):                       # Test nested serialization
         class NestedEnum(Enum):
             NESTED_LIST = [1, [2, 3], {'inner': 'dict'}]
             NESTED_DICT = {'list': [1, 2], 'dict': {'a': 'b'}}
 
         result_list = serialize_to_dict(NestedEnum.NESTED_LIST)
-        assert result_list == [1, [2, 3], {'inner': 'dict'}]
+        assert result_list == 'NESTED_LIST' #[1, [2, 3], {'inner': 'dict'}]
 
         result_dict = serialize_to_dict(NestedEnum.NESTED_DICT)
-        assert result_dict == {'list': [1, 2], 'dict': {'a': 'b'}}
+        assert result_dict == 'NESTED_DICT' # {'list': [1, 2], 'dict': {'a': 'b'}}
 
     def test_enum_with_unsupported_value_types(self):                    # Test fallback to .name
         class CustomClass:
@@ -1042,10 +1051,15 @@ class ComplexEnum(Enum):
         serialized_set   = serialize_to_dict(ComplexEnum.SET_VAL)
 
         # Verify serialization results
-        assert serialized_list  == [1, 2, 3]
-        assert serialized_dict  == {'key': 'value', 'count': 42}
-        assert serialized_tuple == ['a', 'b', 'c']                            # Tuple becomes list
-        assert sorted(serialized_set) == ['x', 'y', 'z']                      # Set becomes list
+        #assert serialized_list  == [1, 2, 3]
+        #assert serialized_dict  == {'key': 'value', 'count': 42}
+        #assert serialized_tuple == ['a', 'b', 'c']                            # Tuple becomes list
+        #assert sorted(serialized_set) == ['x', 'y', 'z']                      # Set becomes list
+
+        assert serialized_list        == 'LIST_VAL'
+        assert serialized_dict        == 'DICT_VAL'
+        assert serialized_tuple       == 'TUPLE_VAL'
+        assert serialized_set         == 'SET_VAL'
 
         # Round-trip test - Type_Safe with enum
         class Schema__Config(Type_Safe):
@@ -1145,4 +1159,49 @@ class Schema__Settings(Type_Safe):
         assert sorted(restored.active_tags) == sorted(list(DataEnum.DEFAULT_TAGS.value))
         assert restored.config_map == DataEnum.DEFAULT_MAP.value
         assert restored.values == DataEnum.DEFAULT_LIST.value
-        assert restored.sequence == list(DataEnum.DEFAULT_TUPLE.value)
+        assert restored.sequence == list(DataEnum.DEFAULT_TUPLE.value)
+
+    def test__regression__from_json__enum_tuple_support(self):
+        from enum import Enum
+
+        class An_Enum(tuple, Enum):
+            AB = ('a', 'b')
+            CD = ('c', 'd')
+
+        class An_Class(Type_Safe):
+            an_enum : An_Enum
+
+        assert An_Class().obj()  == __()                # is this a bug?
+        assert An_Class().obj()  == __(an_enum = None)
+        assert An_Class().json() == {'an_enum': None}
+        assert An_Class(an_enum='AB'      ).an_enum == An_Enum.AB
+        assert An_Class(an_enum=An_Enum.AB).an_enum == An_Enum.AB
+        assert An_Class(an_enum=An_Enum.AB).an_enum == ('a', 'b')
+        assert An_Class(an_enum='AB'      ).an_enum == ('a', 'b')
+        assert An_Class(an_enum=An_Enum.AB).an_enum != An_Enum.CD
+
+        assert An_Class.from_json(An_Class().json()).json() == {'an_enum': None}
+        #error_message = "unhashable type: 'list'"
+        #with pytest.raises(TypeError, match=error_message):
+        #    An_Class.from_json(An_Class(an_enum='AB').json())            # BUG, this should have worked
+        An_Class.from_json(An_Class(an_enum='AB').json())
+
+        an_class = An_Class(an_enum=An_Enum.CD)
+        # with pytest.raises(TypeError, match=error_message):
+        #     An_Class.from_json(an_class.json())                         # BUG, this should have worked
+        An_Class.from_json(an_class.json())
+        #with pytest.raises(TypeError, match=error_message):
+        #assert an_class.json() == {'an_enum': ['c', 'd']}               # BUG this be shoud be 'CD'?
+        assert an_class.json() == {'an_enum': 'CD' }
+
+        # error_message_2 = ("assert {'an_enum': ['c', 'd']} == {'an_enum': <An_Enum.CD: ('c', 'd')>}\n  \n  "
+        #                    "Differing items:\n  {'an_enum': ['c', 'd']} != "
+        #                    "{'an_enum': <An_Enum.CD: ('c', 'd')>}\n  \n  "
+        #                    "Full diff:\n    {\n  -     'an_enum': <An_Enum.CD: ('c', 'd')>,\n  +    "
+        #                    " 'an_enum': [\n  +         'c',\n  +         'd',\n  +     ],\n    }")
+        # with pytest.raises(AssertionError, match=re.escape(error_message_2)):
+        #     assert an_class.json() == {'an_enum': An_Enum.CD}               #
+        assert an_class.json() == {'an_enum': 'CD'}
+        assert An_Class.from_json({'an_enum': 'CD'}      ).an_enum == ('c', 'd')
+        assert An_Class.from_json({'an_enum': An_Enum.CD}).an_enum == ('c', 'd')
+        assert An_Class.from_json(An_Class(an_enum='AB').json()).json() == {'an_enum': 'AB'}