fixed edge case with type_safe decorator where it wasn't converting return values

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py

@@ -9,12 +9,23 @@
 class Type_Safe__List(Type_Safe__Base, list):
     expected_type : Type = None                         # Class-level default
 
-    def __init__(self, expected_type=None, *args):
-        super().__init__(*args)
-        self.expected_type = expected_type or self.__class__.expected_type
-        if self.expected_type is None:
+    def __init__(self, expected_type=None, initial_data=None):
+        super().__init__()                                                                  # Initialize empty list first
+
+        if isinstance(expected_type, list) and initial_data is None:                        # Smart detection: if expected_type is a list and initial_data is None
+            initial_data  = expected_type                                                   # They're using the pattern: An_List(['a', 'b'])
+            expected_type = None                                                            # Move the list to initial_data
+
+        self.expected_type = expected_type or self.__class__.expected_type                  # Use provided type, or fall back to class-level attribute
+
+        if self.expected_type is None:                                                      # Validate that we have type set (either from args or class)
             raise ValueError(f"{self.__class__.__name__} requires expected_type")
 
+        if initial_data is not None:                                                        # Process initial data through our type-safe append
+            for item in initial_data:
+                self.append(item)                                                           # let the .append() check the type_safety
+
+
     def __contains__(self, item):
         if super().__contains__(item):                                                                                          # First try direct lookup
             return True

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py

@@ -7,12 +7,22 @@
 class Type_Safe__Set(Type_Safe__Base, set):
     expected_type : Type = None                         # Class-level default
 
-    def __init__(self, expected_type=None, *args):
-        super().__init__(*args)
-        self.expected_type = expected_type or self.__class__.expected_type
-        if self.expected_type is None:
+    def __init__(self, expected_type=None, initial_data=None):
+        super().__init__()                                                                  # Initialize empty set first
+
+        if isinstance(expected_type, (set, frozenset)) and initial_data is None:            # Smart detection
+            initial_data  = expected_type                                                   # They're using the pattern: An_Set({'a', 'b'})
+            expected_type = None                                                            # Move the set to initial_data
+
+        self.expected_type = expected_type or self.__class__.expected_type                  # Use provided type, or fall back to class-level attribute
+
+        if self.expected_type is None:                                                      # Validate that we have type set
             raise ValueError(f"{self.__class__.__name__} requires expected_type")
 
+        if initial_data is not None:                                                        # Process initial data through our type-safe add
+            for item in initial_data:
+                self.add(item)
+
     def __contains__(self, item):
         if super().__contains__(item):                                                                  # First try direct lookup
             return True

osbot_utils/type_safe/type_safe_core/decorators/type_safe.py

@@ -1,7 +1,9 @@
 import functools                                                                                    # For wrapping functions
+from typing                                                         import get_args
 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.methods.Type_Safe__Method import Type_Safe__Method
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache   import type_safe_cache
 
 
 def type_safe(func):                                                                                # Main decorator function
@@ -30,6 +32,8 @@ def wrapper(*args, **kwargs):
         if return_type is not None and result is not None:                                          # Validate return type using existing type checking infrastructure
             if isinstance(return_type, type) and issubclass(return_type, Type_Safe__Primitive):     # Try to convert Type_Safe__Primitive types
                 result = return_type(result)                                                        # Since we are using a Type_Safe__Primitive, if there is bad data (like a negative number in Safe_UInt) this will trigger an exception
+
+            result = convert_return_value(result, return_type)                                      # todo: refactor convert_return_value into another class (maybe validator or a new converter class)
             try:
                 validator.is_instance_of_type(result, return_type)
             except TypeError as e:
@@ -38,3 +42,57 @@ def wrapper(*args, **kwargs):
         return result
     return wrapper                                                                                  # Return wrapped function
 
+
+# todo: see if we can optmise this return value conversion, namely in detecting if a conversion is needed
+def convert_return_value(result, return_type):
+    """Convert return value to match expected type with auto-conversion."""
+    from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
+    from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Set  import Type_Safe__Set
+    from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict import Type_Safe__Dict
+
+    origin = type_safe_cache.get_origin(return_type)
+    args   = get_args(return_type)
+
+    # # Handle List[T] -> Type_Safe__List conversion
+    if origin is list and args and isinstance(result, list) and not isinstance(result, Type_Safe__List):
+        item_type = args[0]
+        type_safe_list = Type_Safe__List(expected_type=item_type)
+        for item in result:
+            type_safe_list.append(item)  # Auto-converts items
+        return type_safe_list
+
+    # Handle Set[T] -> Type_Safe__Set conversion
+    if origin is set and args and isinstance(result, set) and not isinstance(result, Type_Safe__Set):
+        item_type = args[0]
+        type_safe_set = Type_Safe__Set(expected_type=item_type)
+        for item in result:
+            type_safe_set.add(item)  # Auto-converts items
+        return type_safe_set
+
+    # Handle Dict[K, V] -> Type_Safe__Dict conversion
+    if origin is dict and args and len(args) == 2 and isinstance(result, dict) and not isinstance(result, Type_Safe__Dict):
+        key_type, value_type = args
+        type_safe_dict = Type_Safe__Dict(expected_key_type=key_type, expected_value_type=value_type)
+        for k, v in result.items():
+            type_safe_dict[k] = v  # Auto-converts keys and values
+        return type_safe_dict
+
+    # Handle Type_Safe__List subclass directly (e.g., -> An_List)
+    if isinstance(return_type, type) and issubclass(return_type, Type_Safe__List):
+        if isinstance(result, list) and not isinstance(result, return_type):
+            return return_type(result)  # Uses nice constructor: An_List(['a', 'b'])
+        return result
+
+    # Handle Type_Safe__Set subclass directly (e.g., -> An_Set)
+    if isinstance(return_type, type) and issubclass(return_type, Type_Safe__Set):
+        if isinstance(result, (set, list, tuple)) and not isinstance(result, return_type):
+            return return_type(result)  # Uses nice constructor: An_Set({'a', 'b'})
+        return result
+
+    # Handle Type_Safe__Dict subclass directly (e.g., -> Hash_Mapping)
+    if isinstance(return_type, type) and issubclass(return_type, Type_Safe__Dict):
+        if isinstance(result, dict) and not isinstance(result, return_type):
+            return return_type(result)  # Uses nice constructor: Hash_Mapping({'key': 'val'})
+        return result
+
+    return result

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

@@ -6,7 +6,6 @@
 
 class test_Type_Safe__List__bugs(TestCase):
 
-
     def test__bug__type_safe_list_with_callable(self):
         from typing import Callable
 

tests/unit/type_safe/type_safe_core/decorators/test__decorator__type_safe.py

@@ -433,7 +433,8 @@ def return_list_wrong() -> List[int]:
 
         assert return_list_int() == [1, 2, 3]
 
-        with pytest.raises(TypeError, match="return type validation failed"):
+        error_message = "In Type_Safe__List: Invalid type for item: Expected 'int', but got 'str'"
+        with pytest.raises(TypeError, match=re.escape(error_message)):
             return_list_wrong()
 
 
@@ -472,10 +473,12 @@ def return_dict_wrong_value() -> Dict[str, int]:
 
         assert return_dict() == {"a": 1, "b": 2}
 
-        with pytest.raises(TypeError, match="return type validation failed"):
+        error_message_1 = "Expected 'str', but got 'int'"
+        with pytest.raises(TypeError, match=error_message_1):
             return_dict_wrong_key()
 
-        with pytest.raises(TypeError, match="return type validation failed"):
+        error_message_2 = "Expected 'int', but got 'str'"
+        with pytest.raises(TypeError, match=error_message_2):
             return_dict_wrong_value()
 
 

tests/unit/type_safe/type_safe_core/decorators/test__decorator__type_safe__bugs.py

@@ -1,12 +1,64 @@
+import re
+
 import pytest
-from typing                                                                    import List, Dict, Callable
-from unittest                                                                  import TestCase
-from osbot_utils.type_safe.Type_Safe                                           import Type_Safe
-from osbot_utils.type_safe.type_safe_core.decorators.type_safe                 import type_safe
+from typing                                                                     import List, Dict, Callable
+from unittest                                                                   import TestCase
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Id import Safe_Str__Id
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List           import Type_Safe__List
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                  import type_safe
 
 
 class test__decorator__type_safe__bugs(TestCase):
 
+    def test__regression__type_safe_decorator__doesnt_auto_convert_lists_return_value(self):
+
+        #BUG 1
+        @type_safe
+        def an_function_1(value:str) -> List[Safe_Str__Id]:
+            values = ['42', value]
+            return values
+
+        # error_message_1 = "Function 'test__decorator__type_safe__bugs.test__bug__type_safe_decorator__doesnt_auto_convert_lists_return_value.<locals>.an_function_1' return type validation failed: In list at index 0: Expected 'Safe_Str__Id', but got 'str'"
+        # with pytest.raises(TypeError, match=re.escape(error_message_1)):
+        #     an_function_1('is the answer')                                        # BUG
+        assert an_function_1('is the answer')       == ['42', 'is_the_answer']      # FIXED
+        assert an_function_1('is the answer').obj() == ['42', 'is_the_answer']      # FIXED
+
+        # BUG 2
+        class An_List(Type_Safe__List):
+            expected_type = Safe_Str__Id
+
+        @type_safe
+        def an_function_2(value:str) -> An_List:
+            values= ['42', value]
+            return values
+
+        # error_message_2 = "In Type_Safe__List: Invalid type for item: Expected 'An_List', but got 'str'"
+        # with pytest.raises(TypeError, match=re.escape(error_message_2)):
+        #     an_function_2('is the answer')                                  # BUG
+
+        assert an_function_2('is the answer')       == ['42', 'is_the_answer']      # FIXED
+        assert an_function_2('is the answer').obj () == ['42', 'is_the_answer']      # FIXED
+        assert an_function_2('is the answer').json() == ['42', 'is_the_answer']      # FIXED
+
+        # Control test 1
+
+        @type_safe
+        def an_function_3(value:str) -> List[Safe_Str__Id]:
+            an_list = Type_Safe__List(expected_type=Safe_Str__Id)
+            values  = ['42', value]
+            an_list.extend(values)
+            return an_list
+
+        an_function_3('is the answer')
+
+        # # Control test 2
+        an_list_1 = Type_Safe__List(expected_type=Safe_Str__Id)
+        values_1  = ['42', 'value']
+        an_list_1.extend(values_1)
+        assert type(an_list_1) is Type_Safe__List
+        assert type(an_list_1[0]) is Safe_Str__Id
+        assert an_list_1 == ['42', 'value']
 
     def test__bug__type_safe__list_callable_with_signatures(self):
 
@@ -63,3 +115,4 @@ def create_openapi_spec(servers: List[Dict[str, str]]):
 
 
 
+