added fix for edge case in Type_Safe__Method use of lists inside dicts

Author: DinisCruz

osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py

@@ -2,6 +2,7 @@
 import inspect                                                                                                                       # For function introspection
 from enum                                                                     import Enum
 from typing                                                                   import get_args, get_origin, Union, List, Any, Dict    # For type hinting utilities
+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.shared.Type_Safe__Annotations       import type_safe_annotations
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
@@ -244,18 +245,24 @@ def validate_direct_type(self, param_name: str, param_value: Any, expected_type:
 
                 if value_type is Any:                                                                       # if value type is Any, we don't need to do any checks since they will all match
                     return True
+
+                validator = Type_Safe__Base()
                 for k, v in param_value.items():
-                    if get_origin(key_type) is None:
+                    if get_origin(key_type) is None:                                                        # Validate key (existing logic)
                         if not isinstance(k, key_type):
                             raise ValueError(f"Dict key '{k}' expected type {key_type}, but got {type(k)}")
                     else:
-                        raise NotImplementedError(f"Validation for subscripted key type '{key_type}' not yet supported in parameter '{param_name}'")
+                        try:
+                            validator.is_instance_of_type(k, key_type)
+                        except TypeError as e:
+                            raise ValueError(f"Dict key '{k}' in parameter '{param_name}': {e}") from None
+
+                    if value_type is not Any:                                                               # Validate value
+                        try:
+                            validator.is_instance_of_type(v, value_type)
+                        except TypeError as e:
+                            raise ValueError(f"Dict value for key '{k}' in parameter '{param_name}': {e}") from None
 
-                    if get_origin(value_type) is None:
-                        if not isinstance(v, value_type):
-                            raise ValueError(f"Dict value for key '{k}' expected type {value_type}, but got {type(v)}")
-                    elif value_type is not Any:
-                        raise NotImplementedError(f"Validation for subscripted value type '{value_type}' not yet supported in parameter '{param_name}'")
                 return True
             base_type = origin
         else:

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

@@ -348,7 +348,8 @@ def an_method__static(attributes: Dict[str, An_Attribute]):
         # with pytest.raises(TypeError, match="Subscripted generics cannot be used with class and instance checks"):
         #     an_method__static({'aaa': 'abc'       })                                      # Fixed: BUG: should have failed with type safe check
 
-        with pytest.raises(ValueError, match=re.escape("Dict value for key 'aaa' expected type <class 'test__decorator__type_safe__regression.test_decorator__type_safe__regression.test__regression__dict_attribute_fail.<locals>.An_Attribute'>, but got <class 'str'>")):
+        error_message = "Dict value for key 'aaa' in parameter 'attributes': Expected 'An_Attribute', but got 'str'"
+        with pytest.raises(ValueError, match=re.escape(error_message)):
             an_method__static({'aaa': 'abc'       })                                        # Fixed: BUG: should have failed with type safe check
         #
         # with pytest.raises(TypeError, match="Subscripted generics cannot be used with class and instance checks"):

tests/unit/type_safe/type_safe_core/methods/test_Type_Safe__Method.py

@@ -160,7 +160,8 @@ def func_with_dict(data: Dict[str, int]) -> None:
         # Invalid: wrong value type
         with self.assertRaises(ValueError) as context:
             checker.validate_direct_type('data', {"key": "value"}, Dict[str, int])
-        assert "Dict value for key 'key' expected type" in str(context.exception)
+        #assert "Dict value for key 'key' expected type" in str(context.exception)
+        assert str(context.exception) == "Dict value for key 'key' in parameter 'data': Expected 'int', but got 'str'"
 
     # Test Any type handling
     def test_validate_direct_type__any_type(self):                                      # Test that Any type accepts anything