added major new feature to Type_Safe__Dict which now can be used as a base class (in a way that is compatible with how it was used before)

fixed couple more bugs with Type_Safe__Dict usage in Type_Safe objects (making is more consistent)

Author: DinisCruz

osbot_utils/type_safe/Type_Safe__Base.py

@@ -122,6 +122,9 @@ def is_instance_of_type(self, item, expected_type):
 
     def try_convert(self, value, expected_type):    # Try to convert value to expected type using Type_Safe conversion logic.
 
+        from osbot_utils.type_safe.Type_Safe            import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
         if expected_type is Any:                                    # Handle Any type
             return value
 
@@ -132,6 +135,17 @@ def try_convert(self, value, expected_type):    # Try to convert value to expect
         if isinstance(value, expected_type):        # If already correct type, return as-is
             return value
 
+
+        if (isinstance(expected_type, type) and             # Handle dict → Type_Safe conversion
+            issubclass(expected_type, Type_Safe) and
+            isinstance(value, dict)):
+            return expected_type.from_json(value)
+
+        if (isinstance(expected_type, type) and                 # Handle dict → Type_Safe__Primitive conversion
+            issubclass(expected_type, Type_Safe__Primitive) and
+            type(value) in [str, int, float]):
+            return expected_type(value)
+
         if isinstance(expected_type, type) and type(value) in [str, int, float]:        # For types that are subclasses of built-ins (like Safe_Id extends str)
             if issubclass(expected_type, type(value)):                                  # Only convert if the value's type is a base class of expected_type. e.g., str → Safe_Id (ok), but not int → str (not ok)
                 return expected_type(value)                                             # convert value to expected_type

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -8,11 +8,31 @@
 
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
-    def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    expected_key_type   : Type = None                                                                          # Class-level defaults
+    expected_value_type : Type = None
 
-        self.expected_key_type   = expected_key_type
-        self.expected_value_type = expected_value_type
+    def __init__(self, expected_key_type=None, expected_value_type=None, initial_data=None, **kwargs):
+        super().__init__()                                                                              # Initialize empty dict first
+
+
+        if isinstance(expected_key_type, dict) and expected_value_type is None:                                 # Smart detection: if expected_key_type is a dict and expected_value_type is None, then the user is trying to pass initial data in the old style
+            initial_data      = expected_key_type                                                               # They're using the pattern: Hash_Mapping({'key': 'value'})
+            expected_key_type = None                                                                            # Move the dict to initial_data
+
+        self.expected_key_type   = expected_key_type   or self.__class__.expected_key_type                      # Use provided types, or fall back to class-level attributes
+        self.expected_value_type = expected_value_type or self.__class__.expected_value_type
+
+        if self.expected_key_type is None or self.expected_value_type is None:                                  # Validate that we have types set (either from args or class)
+            raise ValueError(f"{self.__class__.__name__} requires expected_key_type and expected_value_type")
+
+        if initial_data is not None:                                                                            # Process initial data through our type-safe __setitem__
+            if not isinstance(initial_data, dict):
+                raise TypeError(f"Initial data must be a dict, got {type(initial_data).__name__}")
+            for key, value in initial_data.items():
+                self[key] = value                                                                               # Goes through __setitem__ with validation
+
+        for key, value in kwargs.items():                                                                       # Also handle keyword arguments (e.g., Hash_Mapping(key1='val1', key2='val2'))
+            self[key] = value
 
     def __contains__(self, key):
         if super().__contains__(key):                                       # First try direct lookup
@@ -105,3 +125,20 @@ def obj(self) -> __:
 
     def values(self) -> Type_Safe__List:
         return Type_Safe__List(self.expected_value_type, super().values())
+
+    def update(self, other=None, **kwargs):
+        """Override update to ensure type safety through __setitem__"""
+        # Handle dict-like object or iterable of key-value pairs
+        if other is not None:
+            if hasattr(other, 'items'):
+                # Dict-like object
+                for key, value in other.items():
+                    self[key] = value  # Goes through __setitem__
+            else:
+                # Iterable of (key, value) pairs
+                for key, value in other:
+                    self[key] = value
+
+        # Handle keyword arguments
+        for key, value in kwargs.items():
+            self[key] = value

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -49,6 +49,12 @@ def deserialize_attribute(self, _self, key, value):
                     return self.deserialize_type__using_value(value)
 
         if value is not None and type(value) is dict:                                       # Handle forward references first
+
+            if isinstance(annotation, type) and issubclass(annotation, Type_Safe__Dict):                            # Handle Type_Safe__Dict subclasses BEFORE forward references
+                if hasattr(annotation, 'expected_key_type') and hasattr(annotation, 'expected_value_type'):         # Get the expected types from the subclass
+                    if annotation.expected_key_type and annotation.expected_value_type:
+                        dict_instance = annotation(value)                                                           # Create instance and populate it
+                        return dict_instance
             forward_ref_result = self.handle_forward_references(_self, annotation, value)
             if forward_ref_result is not None:
                 return forward_ref_result

tests/unit/type_safe/type_safe_core/_regression/test_Type_Safe__regression.py

@@ -642,9 +642,12 @@ class An_Class_2_A(Type_Safe):
                        'an_class_2_b': {'an_str': 'value_1'}}
 
         assert An_Class_2_A.from_json(json_data_2).json() == json_data_2
-        new_error = "Expected 'An_Class_2_B', but got 'dict'"
-        with pytest.raises(TypeError, match=re.escape(new_error)):
-            An_Class_2_A(**json_data_2)
+
+        assert An_Class_2_A(**json_data_2).obj() == __(an_dict=__(key_1=__(an_str='value_1')),
+                                                       an_class_2_b=__(an_str='value_1'))           # and now this works
+
+        assert An_Class_2_A(**json_data_2).obj () == An_Class_2_A.from_json(json_data_2).obj()       # and these now match
+        assert An_Class_2_A(**json_data_2).json() == json_data_2
 
         # so the code below started to fail after the fix to the dict object assissment (see above ""Expected 'An_Class_2_B', but got 'dict'"")
         # this feels ok since we should be using from_json to create new nester objects and not **json_data_2
@@ -1510,10 +1513,8 @@ class An_Class_2_A(Type_Safe):
         assert type(an_class_from_json.an_dict['key_1'])  is An_Class_2_B
         assert an_class_from_json.an_dict['key_1'].an_str == 'value_1'
 
-        expected_error_1 = "Expected 'An_Class_2_B', but got 'dict'"
-        with pytest.raises(TypeError, match=re.escape(expected_error_1)):                           # this doesn't work
-            An_Class_2_A(**an_class_json)                                                           # but that is expected behavior
-        #an_class_2b = An_Class_2_B()
+        assert An_Class_2_A(**an_class_json).json() == an_class_json
+
         an_class_data   = {'an_dict': {'key_1': An_Class_2_B(**{'an_str': 'value_1'})}}             # since this is how it needs to be done, which works
         an_class_from_kwargs = An_Class_2_A(**an_class_data)                                        #   the idea is if a pure json import is needed,
         assert an_class_from_kwargs.json() == an_class_json                                         #   then .from_json(..) is what should be used

tests/unit/type_safe/type_safe_core/collections/test_Type_Safe__Dict.py

@@ -222,8 +222,19 @@ class An_Class(Type_Safe):
 
         an_class = An_Class()
         an_class.an_dict_custom['ok'] = CustomType(a=1, b='abc')
-        with pytest.raises(TypeError, match="Expected 'CustomType', but got 'dict'"):
-            an_class.an_dict_custom['fail'] = {'a': 2, 'b': 'def'}
+
+        assert an_class.obj() == __(an_dict_custom=__(ok=__(a=1, b='abc')))
+        an_class.an_dict_custom['also_works'] = {'a': 2, 'b': 'def'}
+        assert an_class.obj() == __(an_dict_custom=__(ok         = __(a=1, b='abc'),
+                                                      also_works = __(a=2, b='def')))
+
+        error_message = "On CustomType, invalid type for attribute 'b'. Expected '<class 'str'>' but got '<class 'int'>'"
+        with pytest.raises(ValueError, match=re.escape(error_message)):
+            an_class.an_dict_custom['fail'] = {'a': 2, 'b': 42}
+
+        error_message = "Expected 'CustomType', but got 'str'"
+        with pytest.raises(TypeError, match=re.escape(error_message)):
+            an_class.an_dict_custom['fail'] = "42"
 
     def test__dict_with_empty_collections(self):                            # Check that empty dict fields can be assigned without issues.
         class An_Class(Type_Safe):