feat: Add automatic type conversion for Type_Safe__Dict and improve collection support

- Add try_convert() method to Type_Safe__Base for safe type conversions
  - Converts values when expected type is a subclass of value's type (e.g., str → Safe_Id)
  - Handles Any type and subscripted generics (Callable, Union, etc.)
  - Prevents unwanted conversions (e.g., int → str) maintaining type safety

- Enhance Type_Safe__Dict functionality
  - Automatic type conversion in __setitem__ for both keys and values
  - Add context manager support (__enter__/__exit__)
  - Add keys() and values() methods returning Type_Safe__List instances

- Add context manager support to Type_Safe__List for consistency

- Fix bug where Type_Safe__Dict wouldn't accept valid subclass conversions
  - Now accepts strings where Safe_Id expected (since Safe_Id extends str)
  - Maintains type safety by only allowing base class → subclass conversions

- Reorganize tests: move regression tests to proper test file

This improves developer experience by reducing boilerplate while maintaining
the strong type safety guarantees that Type_Safe provides.

Fixes: Type_Safe__Dict string to Safe_Id conversion

Author: DinisCruz

docs/type_safe/safe-str-int-float-classes-in-osbot-utils.md

@@ -104,8 +104,25 @@ def is_instance_of_type(self, item, expected_type):
                 actual_type_name = type_str(type(item))
                 raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-    # def json(self):
-    #     pass
+    def try_convert(self, value, expected_type):    # Try to convert value to expected type using Type_Safe conversion logic.
+
+        if expected_type is Any:                                    # Handle Any type
+            return value
+
+        origin = type_safe_cache.get_origin(expected_type)          # Handle subscripted generics (like Callable, Union, etc.)
+        if origin is not None:
+            return value                                            # Can't convert generic types, let type check handle it
+
+        if isinstance(value, expected_type):        # If already correct type, return as-is
+            return 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
+
+
+        # Return original if no conversion possible
+        return value
 
 # todo: see if we should/can move this to the Objects.py file
 def type_str(tp):

osbot_utils/type_safe/Type_Safe__Base.py

@@ -1,4 +1,7 @@
 from typing                                import Type
+
+from osbot_utils.type_safe.Type_Safe__List import Type_Safe__List
+
 from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
@@ -9,10 +12,15 @@ def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
         self.expected_value_type = expected_value_type
 
     def __setitem__(self, key, value):                                  # Check type-safety before allowing assignment.
+        key   = self.try_convert(key  , self.expected_key_type  )
+        value = self.try_convert(value, self.expected_value_type)
         self.is_instance_of_type(key  , self.expected_key_type)
         self.is_instance_of_type(value, self.expected_value_type)
         super().__setitem__(key, value)
 
+    def __enter__(self): return self
+    def __exit__ (self, type, value, traceback): pass
+
     # def __repr__(self):
     #     key_type_name   = type_str(self.expected_key_type)
     #     value_type_name = type_str(self.expected_value_type)
@@ -38,3 +46,9 @@ def json(self):
             else:                                                                           # Regular values can be used as-is
                 result[key] = value
         return result
+
+    def keys(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_key_type, super().keys())
+
+    def values(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_value_type, super().values())

osbot_utils/type_safe/Type_Safe__Dict.py

@@ -10,6 +10,9 @@ def __repr__(self):
         expected_type_name = type_str(self.expected_type)
         return f"list[{expected_type_name}] with {len(self)} elements"
 
+    def __enter__(self): return self
+    def __exit__ (self, type, value, traceback): pass
+
     def append(self, item):
         from osbot_utils.type_safe.Type_Safe import Type_Safe
         if type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe) and type(item) is dict:  # if self.expected_type is Type_Safe and we have a dict

osbot_utils/type_safe/Type_Safe__List.py

@@ -1,42 +1,18 @@
 import pytest
 from typing import Any, Dict, Type, Set
 from unittest                               import TestCase
-from osbot_utils.type_safe.Type_Safe        import Type_Safe
-from osbot_utils.type_safe.Type_Safe__Dict  import Type_Safe__Dict
 
+from osbot_utils.type_safe.Type_Safe__List import Type_Safe__List
 
-class test_Type_Safe__Dict__bugs(TestCase):
-
-    def test__bug__doesnt_support__nested__json__with_mixed_content(self):
-        class TestTypeSafe(Type_Safe):
-            value: str
+from osbot_utils.utils.Objects import base_classes
 
-        safe_dict = Type_Safe__Dict(str, Any)
-        safe_dict["number"] = 42
-        safe_dict["string"] = "text"
-        safe_dict["type_safe"] = TestTypeSafe(value="safe")
-        safe_dict["list"] = [1, TestTypeSafe(value="in_list"), {"nested": TestTypeSafe(value="in_dict")}]
-        safe_dict["dict"] = {
-            "normal": "value",
-            "safe_obj": TestTypeSafe(value="in_nested_dict")
-        }
+from osbot_utils.helpers.Safe_Id import Safe_Id
 
+from osbot_utils.type_safe.Type_Safe        import Type_Safe
+from osbot_utils.type_safe.Type_Safe__Dict  import Type_Safe__Dict
 
-        expected = {
-            "number": 42,
-            "string": "text",
-            "type_safe": {"value": "safe"},
-            "list": [1, {"value": "in_list"}, {"nested": {"value": "in_dict"}}],
-            "dict": {
-                "normal": "value",
-                "safe_obj": {"value": "in_nested_dict"}
-            }
-        }
-        assert safe_dict.json() != expected                                         # BUG should be equal
-        assert safe_dict.json()['list'][2]['nested'] != {"value": "in_dict"}
-        assert safe_dict.json()['list'][2]['nested'].value == 'in_dict'
-        assert type(safe_dict.json()['list'][2]['nested']) is TestTypeSafe
 
+class test_Type_Safe__Dict__bugs(TestCase):
 
     def test__bug__json__with_nested_dicts(self):
         class TestTypeSafe(Type_Safe):

tests/unit/type_safe/_bugs/test_Type_Safe__Dict__bugs.py

@@ -1,12 +1,95 @@
 import pytest
 from unittest                               import TestCase
-from typing                                 import Dict, Type, Set
+from typing                                 import Dict, Type, Set, Any
+from osbot_utils.type_safe.Type_Safe__List  import Type_Safe__List
+from osbot_utils.utils.Objects              import base_classes
+
+from osbot_utils.helpers.Safe_Id import Safe_Id
+
 from osbot_utils.type_safe.Type_Safe        import Type_Safe
 from osbot_utils.type_safe.Type_Safe__Dict  import Type_Safe__Dict
 
 
 class test_Type_Safe__Dict__regression(TestCase):
 
+    def test__regression__str_to_safe_id__conversion_not_supports(self):
+        class An_Class(Type_Safe):
+            an_dict: Dict[Safe_Id, Safe_Id]
+        an_class = An_Class()
+        an_class.an_dict[Safe_Id("aaa")] = Safe_Id("bbbb")  # strongly typed
+        assert isinstance(Safe_Id, str) is False            # confirm Safe_Id is not a direct string
+        assert issubclass(Safe_Id, str) is True             # but has str as a base class
+        assert base_classes(Safe_Id) == [str, object]       # also confirmed by the base class list
+        #with pytest.raises(TypeError, match="Expected 'Safe_Id', but got 'str'") :
+        #    an_class.an_dict[Safe_Id("aaa")] = "bbbb"                                                       # FIXED: BUG: this should be supported since we can convert the str into Safe_Id
+        #with pytest.raises(TypeError, match="Expected 'Safe_Id', but got 'str'") :
+        #    an_class.an_dict["ccc"] = Safe_Id("dddd")                                                       # FIXED: BUG: this should be supported since we can convert the str into Safe_Id
+
+        # confirm direct assigment now works
+        an_class.an_dict[Safe_Id("aaa")] = "bbbb"
+        an_class.an_dict["ccc"         ] = Safe_Id("dddd")
+        assert type(an_class.an_dict["aaa"]) is Safe_Id
+        assert type(an_class.an_dict["ccc"]) is Safe_Id
+        for key, value in an_class.an_dict.items():
+            assert type(key) is Safe_Id
+            assert type(value) is Safe_Id
+
+        # confirm kwargs assigment now works
+        kwargs = dict(an_dict={        "an_key_1" :"an_value_1"         ,
+                               Safe_Id("an_key_2"): "an_value_2"          ,
+                                       "an_key_3" : Safe_Id("an_value_3" )})
+        an_class_2 = An_Class(**kwargs)
+
+        with an_class_2.an_dict as _:
+            for key, value in _.items():
+                assert type(key) is Safe_Id
+                assert type(value) is Safe_Id
+
+        with an_class_2.an_dict.keys() as _:
+            assert type(_)          is Type_Safe__List
+            assert _.expected_type  is Safe_Id
+            assert _                == ['an_key_1', 'an_key_2', 'an_key_3']
+            assert _                == [Safe_Id('an_key_1'), 'an_key_2', 'an_key_3']
+            assert _                == [Safe_Id('an_key_1'), Safe_Id('an_key_2'), Safe_Id('an_key_3')]
+
+        with an_class_2.an_dict.values() as _:
+            assert type(_) is Type_Safe__List
+            assert _.expected_type is Safe_Id
+            assert _                == [        'an_value_1',          'an_value_2',          'an_value_3']
+            assert _                == [Safe_Id('an_value_1'),         'an_value_2',          'an_value_3']
+            assert _                == [Safe_Id('an_value_1'), Safe_Id('an_value_2'), Safe_Id('an_value_3')]
+
+    def test__bug__doesnt_support__nested__json__with_mixed_content(self):
+        class TestTypeSafe(Type_Safe):
+            value: str
+
+        safe_dict = Type_Safe__Dict(str, Any)
+        safe_dict["number"] = 42
+        safe_dict["string"] = "text"
+        safe_dict["type_safe"] = TestTypeSafe(value="safe")
+        safe_dict["list"] = [1, TestTypeSafe(value="in_list"), {"nested": TestTypeSafe(value="in_dict")}]
+        safe_dict["dict"] = {
+            "normal": "value",
+            "safe_obj": TestTypeSafe(value="in_nested_dict")
+        }
+
+
+        expected = {
+            "number": 42,
+            "string": "text",
+            "type_safe": {"value": "safe"},
+            "list": [1, {"value": "in_list"}, {"nested": {"value": "in_dict"}}],
+            "dict": {
+                "normal": "value",
+                "safe_obj": {"value": "in_nested_dict"}
+            }
+        }
+        assert safe_dict.json() != expected                                         # BUG should be equal
+        assert safe_dict.json()['list'][2]['nested'] != {"value": "in_dict"}
+        assert safe_dict.json()['list'][2]['nested'].value == 'in_dict'
+        assert type(safe_dict.json()['list'][2]['nested']) is TestTypeSafe
+
+
     def test__regression__type_keys_in_json(self):
 
         class Bug_Type_Keys:                                                       # Simple class for testing