couple edge case fixes with @type_safe decorator

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py

@@ -195,6 +195,17 @@ def validate_list_type(self, param_name: str,
                 if not callable(item):                                                                                              # Check item is callable
                     raise ValueError(f"List item at index {i} expected callable but got {type(item)}")                              # Raise error if not callable
                 # Note: Full signature validation would require is_callable_compatible method
+        elif item_origin is type:                                                                                               # Handle Type[T] items (e.g., List[Type[BaseClass]])
+            type_args = get_args(item_type)                                                                                     # Get T from Type[T]
+            for i, item in enumerate(param_value):                                                                              # Validate each type in list
+                if not isinstance(item, type):                                                                                  # Check item is actually a type/class
+                    raise ValueError(f"List item at index {i} expected a type/class but got {type(item).__name__}")
+                if type_args:                                                                                                   # If Type[T] has type argument (e.g., Type[BaseClass])
+                    required_base = type_args[0]                                                                                # Get the required base type
+                    if isinstance(required_base, type):                                                                         # Only validate if we have a concrete type
+                        if not issubclass(item, required_base):                                                                 # Check item is subclass of T
+                            raise ValueError(f"List item at index {i} expected subclass of {required_base.__name__}, "
+                                           f"but got {item.__name__}")
         elif item_origin is not None:                                                                                               # Handle other subscripted types
             raise NotImplementedError(f"Validation for list items with subscripted type"
                                       f" '{item_type}' is not yet supported "

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -157,6 +157,9 @@ def convert_item_to_type(self, expected_type, item):
             else:
                 return expected_type(**item)
         else:
+            if isinstance(type_safe_cache.get_origin(expected_type), type):
+                resolved_type = self.deserialize_type__using_value(item)
+                return resolved_type
             return expected_type(item)
 
     def handle_special_types(self, _self, key, annotation, value):                          # Handle special types like enums and Type_Safe__Primitive subclasses."""

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

@@ -116,3 +116,6 @@ def create_openapi_spec(servers: List[Dict[str, str]]):
 
 
 
+
+
+

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

@@ -570,4 +570,85 @@ def method_with_kwargs(self, name: str, **kwargs):          # The bug is caused
         # assert result != expected  # BUG: This is what we expect
         # assert result == current   # BUG: This is what we get
         assert result == expected
-        assert result != with_bug
+        assert result != with_bug
+
+    def test__regression__list_of_type_T__not_supported(self):      # Document bug where List[Type[SomeClass]] fails validation in @type_safe decorator
+
+        # Define a base class that we want to use in Type[T]
+        class Base_Handler(Type_Safe):
+            name: str = "base"
+
+        class Handler_A(Base_Handler):
+            name: str = "handler_a"
+
+        class Handler_B(Base_Handler):
+            name: str = "handler_b"
+
+        # Define a class with a @type_safe decorated method that takes List[Type[Base_Handler]]
+        class Executor(Type_Safe):
+
+            @type_safe
+            def execute(self,
+                        handler_classes: List[Type[Base_Handler]],  # This is the problematic type
+                        name: str = "test"
+                   ) -> int:
+                return len(handler_classes)
+
+        # BUG: This should work but raises NotImplementedError
+        with Executor() as executor:
+            # Empty list should work
+            #with pytest.raises(NotImplementedError, match="Validation for list items with subscripted type"):
+            #    executor.execute(handler_classes=[])  # BUG: fails even with empty list
+            assert executor.execute(handler_classes=[]) == 0                    # FIXED
+
+            # List with valid classes should work
+            # with pytest.raises(NotImplementedError, match="Validation for list items with subscripted type"):
+            #     executor.execute(handler_classes=[Handler_A, Handler_B])  # BUG: fails
+            assert executor.execute(handler_classes=[Handler_A, Handler_B]) == 2        # FIXED
+
+    def test__regression__list_of_type_T__expected_behavior(self):      # Document what SHOULD happen when bug is fixed
+
+        class Base_Handler(Type_Safe):
+            name: str = "base"
+
+        class Handler_A(Base_Handler):
+            name: str = "handler_a"
+
+        class Handler_B(Base_Handler):
+            name: str = "handler_b"
+
+        class Unrelated_Class(Type_Safe):
+            value: int = 0
+
+        class Executor(Type_Safe):
+
+            @type_safe
+            def execute(self,
+                        handler_classes: List[Type[Base_Handler]],
+                        name: str = "test"
+                   ) -> int:
+                return len(handler_classes)
+
+        executor = Executor()
+
+        # When fixed, these should be the expected behaviors:
+        #
+        # 1. Empty list should work:
+        assert executor.execute(handler_classes=[]) == 0 # Should return 0
+        #
+        # 2. List with valid subclasses should work:
+        assert executor.execute(handler_classes=[Handler_A, Handler_B]) == 2  # Should return 2
+
+        # 3. List with base class itself should work:
+        assert executor.execute(handler_classes=[Base_Handler]) == 1 # Should return 1
+
+        #
+        # 4. List with non-subclass should raise ValueError:
+        error_message_1 =  "List item at index 0 expected subclass of Base_Handler, but got Unrelated_Class"
+        with pytest.raises(ValueError,match=error_message_1):
+            executor.execute(handler_classes=[Unrelated_Class])
+
+        # 5. List with non-type should raise ValueError:
+        error_message_2 =  "List item at index 0 expected a type/class but got Handler_A"
+        with pytest.raises(ValueError,match=error_message_2):
+            executor.execute(handler_classes=[Handler_A()])  # instance, not class