Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.40.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.40.2-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

osbot_utils/type_safe/Type_Safe__Base.py

@@ -122,8 +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
+        from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive                       import Type_Safe__Primitive
+        from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict import Type_Safe__Dict
 
         if expected_type is Any:                                    # Handle Any type
             return value
@@ -135,12 +136,16 @@ 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__Dict conversion (not working as expected)
+            issubclass(expected_type, Type_Safe__Dict) and
+            isinstance(value, dict)):
+            return expected_type(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]):

osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Convert.py

@@ -1,6 +1,7 @@
-from typing                                                       import get_args
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
-from osbot_utils.utils.Objects                                    import base_classes_names
+from typing                                                           import get_args
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache     import type_safe_cache
+from osbot_utils.utils.Objects                                        import base_classes_names
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict import Type_Safe__Dict
 
 
 class Type_Safe__Convert:
@@ -14,6 +15,9 @@ def convert_dict_to_value_from_obj_annotation(self, target, attr_name, value):
                     if len(args) == 2 and args[1] is type(None):                            # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (which is an shorthand for Union[X, None] )
                         attribute_annotation = args[0]
 
+                    if isinstance(attribute_annotation, type) and issubclass(attribute_annotation, Type_Safe__Dict):
+                        return attribute_annotation(value)                                  # Convert plain dict to subclass
+
                     if 'Type_Safe' in base_classes_names(attribute_annotation):
                         return attribute_annotation(**value)
         return value

osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Validation.py

@@ -200,6 +200,7 @@ def check_if__type_matches__obj_annotation__for_attr(self, target, attr_name, va
             if origin_attr_type is set:
                 if type(value) is list:
                     return True                                                         # if the attribute is a set and the value is a list, then they are compatible
+
             if origin_attr_type is type:                                                # Add handling for Type[T]
                 type_args = get_args(attr_type)
                 if type_args:

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -1,5 +1,6 @@
 from typing                                                             import get_origin, Annotated, get_args, Literal, Union
 from osbot_utils.type_safe.Type_Safe__Primitive                         import Type_Safe__Primitive
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict   import Type_Safe__Dict
 from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List   import Type_Safe__List
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache       import type_safe_cache
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Convert     import type_safe_convert
@@ -11,6 +12,8 @@ class Type_Safe__Step__Set_Attr:
     def resolve_value(self, _self, annotations, name, value):
         if type(value) is dict:
             value = self.resolve_value__dict(_self, name, value)
+        elif isinstance(value, Type_Safe__Dict):
+            value = self.convert_type_safe_dict(annotations, name, value)
         elif type(value) is list:
             value = self.resolve_value__list(_self, name, value)
         elif type(value) is tuple:
@@ -28,6 +31,18 @@ def resolve_value(self, _self, annotations, name, value):
         type_safe_validation.validate_type_compatibility(_self, annotations, name, value)
         return value
 
+    def convert_type_safe_dict(self, annotations, name, value):         # Convert between Type_Safe__Dict subclasses
+
+        expected_type = annotations.get(name)
+
+        if not (isinstance(expected_type, type) and issubclass(expected_type, Type_Safe__Dict)):
+            return value
+
+        if type(value) is expected_type:
+            return value
+
+        return expected_type(dict(value))                               # Create new instance - validation happens automatically
+
     def resolve_value__dict(self, _self, name, value):
         return type_safe_convert.convert_dict_to_value_from_obj_annotation(_self, name, value)
 
@@ -70,6 +85,7 @@ def resolve_value__tuple(self, _self, name, value):                 # Convert re
                     return Type_Safe__Tuple(expected_types=args, items=value)
 
         return value
+
     def resolve_value__from_origin(self, value):
         #origin = type_safe_cache.get_origin(value)                                     # todo: figure out why this is the only place that the type_safe_cache.get_origin doesn't work (due to WeakKeyDictionary key error on value)
         origin = get_origin(value)

osbot_utils/version

@@ -1 +1 @@
-v3.40.0
+v3.40.2

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v3.40.0"
+version     = "v3.40.2"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <[email protected]>"]
 license     = "MIT"

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

@@ -1,8 +1,11 @@
 import re
 import pytest
-from typing                             import Dict, List, Any
-from unittest                           import TestCase
-from osbot_utils.type_safe.Type_Safe    import Type_Safe
+from typing                                                                         import Dict, List, Any
+from unittest                                                                       import TestCase
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+from osbot_utils.type_safe.primitives.domains.cryptography.safe_str.Safe_Str__Hash  import Safe_Str__Hash
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Dict               import Type_Safe__Dict
+
 
 class test_Type_Safe__Dict__bugs(TestCase):
 
@@ -32,3 +35,18 @@ class Schema__Order__Alternative(Type_Safe):
         with Schema__Order__Alternative() as alt_order:
             alt_order.items = [{'product': 'laptop', 'qty': 1}]                          # Works
             assert alt_order.items == [{'product': 'laptop', 'qty': 1}]
+
+    def test__bug__list_of_dict_subclasses_from_plain_dicts(self):
+        from typing import List
+
+        class Hash_Mapping(Type_Safe__Dict):
+            expected_key_type = Safe_Str__Hash
+            expected_value_type = str
+
+        class Container(Type_Safe):
+            mappings: List[Hash_Mapping]
+
+        error_message = "Invalid type for item: Expected 'Hash_Mapping', but got 'dict'"
+        with pytest.raises(TypeError, match=re.escape(error_message)):
+            container = Container(mappings=[{'abc1234567': 'first'},
+                                            {'def4567890': 'second'}])                      # BUG: Lists are currently not supported