Merge dev into main

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/decorators/type_safe.py

@@ -1,5 +1,6 @@
-import functools                                                                           # For wrapping functions
+import functools                                                                                    # For wrapping functions
 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
 
 
@@ -21,6 +22,8 @@ def wrapper(*args, **kwargs):
             result     =  func(**bound_args.arguments)                                              # Call original function
 
         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
             try:
                 validator.is_instance_of_type(result, return_type)
             except TypeError as e:

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

@@ -4,6 +4,7 @@
 from unittest                                                                           import TestCase
 from typing                                                                             import Union, Optional, List, Type, Callable, Any
 from dataclasses                                                                        import dataclass
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                    import Safe_UInt
 from osbot_utils.type_safe.primitives.domains.identifiers.Obj_Id                        import Obj_Id
 from osbot_utils.type_safe.primitives.domains.cryptography.safe_str.Safe_Str__Hash      import Safe_Str__Hash
 from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Name       import Safe_Str__File__Name
@@ -371,20 +372,20 @@ def return_wrong_type() -> int:
         with pytest.raises(TypeError, match="return type validation failed"):
             return_wrong_type()
 
-    def test_return_type_validation__type_safe_primitives(self):
-        """Test return type validation with Type_Safe primitives"""
+    def test_return_type_validation__type_safe_primitives(self):    # Test return type validation with Type_Safe primitives
 
         @type_safe
         def return_safe_id() -> Safe_Id:
             return Safe_Id("test")
 
         @type_safe
         def return_wrong_primitive() -> Safe_Id:
-            return "not a safe_id"
+            return "not a safe_id" * 50                    #  breaks Safe max size of 512
 
         assert type(return_safe_id()) is Safe_Id
 
-        with pytest.raises(TypeError, match="return type validation failed"):
+        error_message = "Invalid ID: The ID must not exceed 512 characters (was 650)."
+        with pytest.raises(ValueError, match=re.escape(error_message)):
             return_wrong_primitive()
 
     def test_return_type_validation__optional(self):
@@ -533,6 +534,44 @@ def process_wrong(value: int) -> str:
         with pytest.raises(ValueError, match="Parameter 'value' expected type"):
             process("not an int")
 
+    def test__type_safe_decorator__converts_return_primitives(self):        # Test that return values are converted to Type_Safe__Primitive types
+
+        @type_safe
+        def returns_safe_uint() -> Safe_UInt:
+            return 42  # int should convert to Safe_UInt
+
+        result = returns_safe_uint()
+        assert isinstance(result, Safe_UInt)
+        assert result == 42
+
+        @type_safe
+        def returns_safe_str() -> Safe_Str:
+            return "hello"  # str should convert to Safe_Str
+
+        result = returns_safe_str()
+        assert isinstance(result, Safe_Str)
+        assert result == "hello"
+
+
+    def test__type_safe_decorator__validates_converted_return_values(self):     # Test that converted values are still validated against constraints
+
+        @type_safe
+        def returns_constrained_uint() -> Safe_UInt:
+            return -1  # Should fail Safe_UInt's min_value=0 constraint
+
+        error_message = 'Safe_UInt must be >= 0, got -1'
+        with pytest.raises(ValueError, match=re.escape(error_message)):
+            returns_constrained_uint()
+
+
+    def test__type_safe_decorator__return_none_with_optional(self): # Test that None is valid for Optional return types
+
+        @type_safe
+        def maybe_returns_uint() -> Optional[Safe_UInt]:
+            return None
+
+        result = maybe_returns_uint()
+        assert result is None
 
 
 

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

@@ -4,6 +4,7 @@
 from typing                                                                             import Any, Dict, Optional, Type, List
 from unittest                                                                           import TestCase
 from osbot_utils.type_safe.primitives.core.Safe_Int                                     import Safe_Int
+from osbot_utils.type_safe.primitives.core.Safe_UInt                                    import Safe_UInt
 from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path       import Safe_Str__File__Path
 from osbot_utils.type_safe.primitives.domains.identifiers.Safe_Id                       import Safe_Id
 from osbot_utils.type_safe.primitives.domains.identifiers.safe_int.Timestamp_Now        import Timestamp_Now
@@ -375,4 +376,15 @@ def method_2(self, value: Any, node_type: type = None):
         with pytest.raises(ValueError, match=expected_error):
             assert An_Class().method_1('a', int) # Fixed was:  == {'value': True, 'node_type': int}  # BUG, value should be 'a'
 
-        assert An_Class().method_2('a', int) == {'node_type': int, 'value': 'a'}            # Fixed
+        assert An_Class().method_2('a', int) == {'node_type': int, 'value': 'a'}            # Fixed
+
+    def test__regression__type_save_method__return_value_cast_to_safe_uint(self):
+        @type_safe
+        def an_method() -> Safe_UInt:
+            return 42
+
+        #error_message = "Function 'test__decorator__type_safe__bugs.test__bug__type_save_method__return_value_cast_to_safe_uint.<locals>.an_method' return type validation failed: Expected 'Safe_UInt', but got 'int'"
+        # with pytest.raises(TypeError, match=re.escape(error_message)):
+        #     an_method()             # BUG: we should handle transparently the conversion into Safe_UInt (and only raise an exeception if the data is bad)
+        assert an_method()       == 42
+        assert type(an_method()) is Safe_UInt