osbot-utils 2.10.0__py3-none-any.whl → 2.12.0__py3-none-any.whl

osbot_utils/type_safe/steps/Type_Safe__Step__Default_Value.py

@@ -0,0 +1,74 @@
+
+import sys
+import inspect
+import typing
+
+from osbot_utils.type_safe.shared.Type_Safe__Cache import type_safe_cache
+from osbot_utils.utils.Objects                     import default_value
+from osbot_utils.type_safe.Type_Safe__List         import Type_Safe__List
+from osbot_utils.type_safe.Type_Safe__Dict         import Type_Safe__Dict
+
+
+# Backport implementations of get_args for Python 3.7        # todo: refactor into separate class (focused on past python version compatibility)
+if sys.version_info < (3, 8):                                           # pragma: no cover
+
+    def get_args(tp):
+        if isinstance(tp, typing._GenericAlias):
+            return tp.__args__
+        else:
+            return ()
+else:
+    from typing import get_args, ForwardRef
+
+
+class Type_Safe__Step__Default_Value:
+
+    def default_value(self, _cls, var_type):
+
+        origin = type_safe_cache.get_origin(var_type)            # todo: refactor this to use the get_origin method
+        if origin is type:                        # Special handling for Type[T]  # todo: reuse the get_origin value
+            type_args = get_args(var_type)
+            if type_args:
+                if isinstance(type_args[0], ForwardRef):
+                    forward_name = type_args[0].__forward_arg__
+                    for base_cls in inspect.getmro(_cls):
+                        if base_cls.__name__ == forward_name:
+                            return _cls                                                      # note: in this case we return the cls, and not the base_cls (which makes sense since this happens when the cls class uses base_cls as base, which has a ForwardRef to base_cls )
+                return type_args[0]                             # Return the actual type as the default value
+
+        if var_type is typing.Set:                              # todo: refactor the dict, set and list logic, since they are 90% the same
+            return set()
+
+        if origin is set:
+            return set()                                        # todo: add Type_Safe__Set
+
+        if var_type is typing.Dict:
+            return {}
+
+        if origin is dict:                        # e.g. Dict[key_type, value_type]
+            key_type, value_type = get_args(var_type)
+            if isinstance(key_type, ForwardRef):                # Handle forward references on key_type ---
+                forward_name = key_type.__forward_arg__
+                if forward_name == _cls.__name__:
+                    key_type = _cls
+            if isinstance(value_type, ForwardRef):              # Handle forward references on value_type ---
+                forward_name = value_type.__forward_arg__
+                if forward_name == _cls.__name__:
+                    value_type = _cls
+            return Type_Safe__Dict(expected_key_type=key_type, expected_value_type=value_type)
+
+        if var_type is typing.List:
+            return []                                           # handle case when List was used with no type information provided
+
+        if origin is list:                        # if we have list defined as list[type]
+            item_type = get_args(var_type)[0]                   #    get the type that was defined
+            if isinstance(item_type, ForwardRef):               # handle the case when the type is a forward reference
+                forward_name = item_type.__forward_arg__
+                if forward_name == _cls.__name__:                #    if the forward reference is to the current class (simple name check)
+                    item_type = _cls                             #       set the item_type to the current class
+            return Type_Safe__List(expected_type=item_type)     #    and used it as expected_type in Type_Safe__List
+        else:
+            return default_value(var_type)                      # for all other cases call default_value, which will try to create a default instance
+
+
+type_safe_step_default_value = Type_Safe__Step__Default_Value()

osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py

@@ -0,0 +1,138 @@
+import sys
+import types
+from decimal                                             import Decimal
+from enum                                                import EnumMeta
+from osbot_utils.type_safe.Type_Safe                     import Type_Safe
+from osbot_utils.type_safe.Type_Safe__List               import Type_Safe__List
+from osbot_utils.helpers.Random_Guid                     import Random_Guid
+from osbot_utils.helpers.Random_Guid_Short               import Random_Guid_Short
+from osbot_utils.type_safe.shared.Type_Safe__Annotations import type_safe_annotations
+from osbot_utils.type_safe.shared.Type_Safe__Cache       import type_safe_cache
+from osbot_utils.utils.Objects                           import enum_from_value
+from osbot_utils.helpers.Safe_Id                         import Safe_Id
+from osbot_utils.helpers.Timestamp_Now                   import Timestamp_Now
+
+# todo; refactor all this python compatibility into the python_3_8 class
+if sys.version_info < (3, 8):                                           # pragma: no cover
+
+    def get_args(tp):
+        import typing
+        if isinstance(tp, typing._GenericAlias):
+            return tp.__args__
+        else:
+            return ()
+else:
+    from typing import get_args, Any
+
+
+class Type_Safe__Step__From_Json:
+
+    # todo: this needs refactoring, since the logic and code is getting quite complex (to be inside methods like this)
+    def deserialize_from_dict(self, _self, data, raise_on_not_found=False):
+
+        if hasattr(data, 'items') is False:
+            raise ValueError(f"Expected a dictionary, but got '{type(data)}'")
+
+        for key, value in data.items():
+            if hasattr(_self, key) and isinstance(getattr(_self, key), Type_Safe):
+                self.deserialize_from_dict(getattr(_self, key), value)                                             # if the attribute is a Type_Safe object, then also deserialize it
+            else:
+                if hasattr(_self, '__annotations__'):                                                        # can only do type safety checks if the class does not have annotations
+                    if hasattr(_self, key) is False:                                                         # make sure we are now adding new attributes to the class
+                        if raise_on_not_found:
+                            raise ValueError(f"Attribute '{key}' not found in '{_self.__class__.__name__}'")
+                        else:
+                            continue
+                    if type_safe_annotations.obj_attribute_annotation(_self, key) == type:                                         # Handle type objects
+                        value = self.deserialize_type__using_value(value)
+                    elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, dict):                                # handle the case when the value is a dict
+                        value = self.deserialize_dict__using_key_value_annotations(_self, key, value)
+                    elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, list):                              # handle the case when the value is a list
+                        attribute_annotation = type_safe_annotations.obj_attribute_annotation(_self, key)                          # get the annotation for this variable
+                        attribute_annotation_args = get_args(attribute_annotation)
+                        if attribute_annotation_args:
+                            expected_type        = get_args(attribute_annotation)[0]                            # get the first arg (which is the type)
+                            type_safe_list       = Type_Safe__List(expected_type)                               # create a new instance of Type_Safe__List
+                            for item in value:                                                                  # next we need to convert all items (to make sure they all match the type)
+                                if type(item) is dict:
+                                    new_item = expected_type(**item)                                                # create new object
+                                else:
+                                    new_item = expected_type(item)
+                                type_safe_list.append(new_item)                                                 # and add it to the new type_safe_list obejct
+                            value = type_safe_list                                                              # todo: refactor out this create list code, maybe to an deserialize_from_list method
+                    else:
+                        if value is not None:
+                            if type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, EnumMeta):            # Handle the case when the value is an Enum
+                                enum_type = getattr(_self, '__annotations__').get(key)
+                                if type(value) is not enum_type:                                    # If the value is not already of the target type
+                                    value = enum_from_value(enum_type, value)                       # Try to resolve the value into the enum
+
+                            # todo: refactor these special cases into a separate method to class
+                            elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, Decimal):           # handle Decimals
+                                value = Decimal(value)
+                            elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, Safe_Id):           # handle Safe_Id
+                                value = Safe_Id(value)
+                            elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, Random_Guid):       # handle Random_Guid
+                                value = Random_Guid(value)
+                            elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, Random_Guid_Short): # handle Random_Guid_Short
+                                value = Random_Guid_Short(value)
+                            elif type_safe_annotations.obj_is_attribute_annotation_of_type(_self, key, Timestamp_Now):     # handle Timestamp_Now
+                                value = Timestamp_Now(value)
+                    setattr(_self, key, value)                                                   # Direct assignment for primitive types and other structures
+
+        return _self
+
+    def deserialize_type__using_value(self, value):
+        if value:
+            try:
+                module_name, type_name = value.rsplit('.', 1)
+                if module_name == 'builtins' and type_name == 'NoneType':                       # Special case for NoneType (which serialises as builtins.* , but it actually in types.* )
+                    value = types.NoneType
+                else:
+                    module = __import__(module_name, fromlist=[type_name])
+                    value = getattr(module, type_name)
+            except (ValueError, ImportError, AttributeError) as e:
+                raise ValueError(f"Could not reconstruct type from '{value}': {str(e)}")
+        return value
+
+    def deserialize_dict__using_key_value_annotations(self, _self, key, value):
+        from osbot_utils.type_safe.Type_Safe__Dict import Type_Safe__Dict
+
+        annotations            = type_safe_cache.get_obj_annotations(_self)
+        dict_annotations_tuple = get_args(annotations.get(key))
+        if not dict_annotations_tuple:                                      # happens when the value is a dict/Dict with no annotations
+            return value
+        if not type(value) is dict:
+            return value
+        key_class   = dict_annotations_tuple[0]
+        value_class = dict_annotations_tuple[1]
+        new_value   = Type_Safe__Dict(expected_key_type=key_class, expected_value_type=value_class)
+
+        for dict_key, dict_value in value.items():
+            if issubclass(key_class, Type_Safe):
+                new__dict_key = self.deserialize_from_dict(key_class(), dict_key)
+            else:
+                new__dict_key = key_class(dict_key)
+
+            if type(dict_value) == value_class:                                        # if the value is already the target, then just use it
+                new__dict_value = dict_value
+            elif issubclass(value_class, Type_Safe):
+                new__dict_value = self.deserialize_from_dict(value_class(), dict_value)
+            elif value_class is Any:
+                new__dict_value = dict_value
+            else:
+                new__dict_value = value_class(dict_value)
+            new_value[new__dict_key] = new__dict_value
+
+        return new_value
+
+    def from_json(self, _cls, json_data, raise_on_not_found=False):
+        from osbot_utils.utils.Json import json_parse
+
+        if type(json_data) is str:
+            json_data = json_parse(json_data)
+        if json_data:                                           # if there is no data or is {} then don't create an object (since this could be caused by bad data being provided)
+            return self.deserialize_from_dict(_cls(), json_data,raise_on_not_found=raise_on_not_found)
+        return _cls()
+
+type_safe_step_from_json = Type_Safe__Step__From_Json()

osbot_utils/type_safe/steps/Type_Safe__Step__Init.py

@@ -0,0 +1,24 @@
+class Type_Safe__Step__Init:
+
+    def init(self, __self         ,
+                   __class_kwargs ,
+                   **kwargs
+             )                   -> None:
+
+        for (key, value) in __class_kwargs.items():                             # assign all default values to target
+            if hasattr(__self, key):
+                existing_value = getattr(__self, key)
+                if existing_value is not None:
+                    setattr(__self, key, existing_value)
+                    continue
+            setattr(__self, key, value)
+
+        for (key, value) in kwargs.items():                                     # overwrite with values provided in ctor
+            if hasattr(__self, key):
+                if value is not None:                                           # prevent None values from overwriting existing values, which is quite common in default constructors
+                    setattr(__self, key, value)
+            else:
+                raise ValueError(f"{__self.__class__.__name__} has no attribute '{key}' and cannot be assigned the value '{value}'. "
+                                 f"Use {__self.__class__.__name__}.__default_kwargs__() see what attributes are available")
+
+type_safe_step_init = Type_Safe__Step__Init()

osbot_utils/type_safe/steps/Type_Safe__Step__Set_Attr.py

@@ -0,0 +1,92 @@
+from typing                                                  import get_origin, Annotated, get_args
+from osbot_utils.type_safe.shared.Type_Safe__Cache           import type_safe_cache
+from osbot_utils.type_safe.shared.Type_Safe__Convert         import type_safe_convert
+from osbot_utils.type_safe.shared.Type_Safe__Validation      import type_safe_validation
+from osbot_utils.type_safe.validators.Type_Safe__Validator   import Type_Safe__Validator
+
+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 type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
+            value = self.resolve_value__int_str(_self, name, value)
+        else:
+            value = self.resolve_value__from_origin(value)
+
+        type_safe_validation.validate_type_compatibility(_self, annotations, name, value)
+        return value
+
+    def resolve_value__dict(self, _self, name, value):
+        return type_safe_convert.convert_dict_to_value_from_obj_annotation(_self, name, value)
+
+    def resolve_value__int_str(self, _self, name, value):
+        immutable_vars = type_safe_cache.get_class_immutable_vars(_self.__class__)      # get the cached value of immutable vars for this class
+
+        if name in immutable_vars:                                                      # we only need to do the conversion if the variable is immutable
+            return value
+
+        return  type_safe_convert.convert_to_value_from_obj_annotation(_self, name, 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)
+
+        if origin is not None:
+            value = origin
+        return value
+
+    def handle_get_class__annotated(self, annotation, name, value):
+        annotation_args = get_args(annotation)
+        target_type = annotation_args[0]
+        for attribute in annotation_args[1:]:
+            if isinstance(attribute, Type_Safe__Validator):
+                attribute.validate(value=value, field_name=name, target_type=target_type)
+
+    def handle_get_class__dict(self, _self, name, value):
+        if value:                                                                                                       # todo: see side effects of doing this here (since going into deserialize_dict__using_key_value_annotations has performance hit)
+            from osbot_utils.type_safe.steps.Type_Safe__Step__From_Json import Type_Safe__Step__From_Json               # here because of circular dependencies
+            value = Type_Safe__Step__From_Json().deserialize_dict__using_key_value_annotations(_self, name, value)      # todo: refactor how this actually works since it is not good to having to use the deserialize_dict__using_key_value_annotations from here
+        return value
+
+    def handle_get_class(self, _self, annotations, name, value):
+        if hasattr(annotations, 'get'):
+            annotation = annotations.get(name)
+            if annotation:
+                annotation_origin = type_safe_cache.get_origin(annotation)
+                if annotation_origin is Annotated:
+                    self.handle_get_class__annotated(annotation, name, value)
+                elif annotation_origin is dict:
+                    value = self.handle_get_class__dict(_self, name, value)
+        return value
+
+    def handle_special_generic_alias(self, _super, _self, name, value):
+        immutable_vars = type_safe_cache.get_class_immutable_vars(_self.__class__)       # todo: refactor this section into a separate method
+        if name in immutable_vars:
+            expected_type = immutable_vars[name]
+            current_type  = type if value is type else type(value)
+            type_safe_validation.validate_if__types_are_compatible_for_assigment(name, current_type, expected_type)
+            _super.__setattr__(name, value)
+            return True
+        return False
+
+    def setattr(self, _super, _self, name, value):
+        if type_safe_validation.check_if__value_is__special_generic_alias(value):
+            if self.handle_special_generic_alias(_super, _self, name, value):
+                return
+
+        annotations = dict(type_safe_cache.get_obj_annotations(_self))
+
+        if not annotations:                                             # can't do type safety checks if the class does not have annotations
+            return _super.__setattr__(name, value)
+
+        if value is not None:
+            value = self.resolve_value          (_self, annotations, name, value)
+            value = self.handle_get_class(_self, annotations, name, value)
+        else:
+            type_safe_validation.validate_if_value_has_been_set(_self, annotations, name, value)
+
+        _super.__setattr__(name, value)
+
+
+type_safe_step_set_attr = Type_Safe__Step__Set_Attr()

osbot_utils/utils/Objects.py

@@ -1,73 +1,10 @@
 # todo add tests
 import sys
-from types                                               import SimpleNamespace
-from osbot_utils.helpers.python_compatibility.python_3_8 import Annotated
-
+from types  import SimpleNamespace
 
 class __(SimpleNamespace):
     pass
 
-# Backport implementations of get_origin and get_args for Python 3.7
-if sys.version_info < (3, 8):
-    def get_origin(tp):
-        import typing
-        if isinstance(tp, typing._GenericAlias):
-            return tp.__origin__
-        elif tp is typing.Generic:
-            return typing.Generic
-        else:
-            return None
-
-    def get_args(tp):
-        import typing
-        if isinstance(tp, typing._GenericAlias):
-            return tp.__args__
-        else:
-            return ()
-else:
-    from typing import get_origin, get_args, List, Tuple, Dict, Type, _GenericAlias, ForwardRef
-
-
-def are_types_compatible_for_assigment(source_type, target_type):
-    import types
-    import typing
-
-    if isinstance(target_type, str):                                    # If the "target_type" is a forward reference (string), handle it here.
-        if target_type == source_type.__name__:                         # Simple check: does the string match the actual class name
-            return True
-    if source_type is target_type:
-        return True
-    if source_type is int and target_type is float:
-        return True
-    if target_type in source_type.__mro__:                              # this means that the source_type has the target_type has of its base types
-        return True
-    if target_type is callable:                                         # handle case where callable was used as the target type
-        if source_type is types.MethodType:                             #     and a method or function was used as the source type
-            return True
-        if source_type is types.FunctionType:
-            return True
-        if source_type is staticmethod:
-            return True
-    if target_type is typing.Any:
-        return True
-    return False
-
-def are_types_magic_mock(source_type, target_type):
-    from unittest.mock import MagicMock
-    if isinstance(source_type, MagicMock):
-        return True
-    if isinstance(target_type, MagicMock):
-        return True
-    if source_type is MagicMock:
-        return True
-    if target_type is MagicMock:
-        return True
-    # if class_full_name(source_type) == 'unittest.mock.MagicMock':
-    #     return True
-    # if class_full_name(target_type) == 'unittest.mock.MagicMock':
-    #     return True
-    return False
-
 def base_classes(cls):
     if type(cls) is type:
         target = cls
@@ -106,46 +43,6 @@ def class_full_name(target):
             type_name   = type_target.__name__
         return f'{type_module}.{type_name}'
 
-def convert_dict_to_value_from_obj_annotation(target, attr_name, value):                    # todo: refactor this with code from convert_str_to_value_from_obj_annotation since it is mostly the same
-    if target is not None and attr_name is not None:
-        if hasattr(target, '__annotations__'):
-            obj_annotations  = target.__annotations__
-            if hasattr(obj_annotations,'get'):
-                attribute_annotation = obj_annotations.get(attr_name)
-                if 'Type_Safe' in base_classes_names(attribute_annotation):
-                    return attribute_annotation(**value)
-    return value
-
-def convert_to_value_from_obj_annotation(target, attr_name, value):                             # todo: see the side effects of doing this for all ints and floats
-
-    from osbot_utils.helpers.Guid           import Guid
-    from osbot_utils.helpers.Timestamp_Now  import Timestamp_Now
-    from osbot_utils.helpers.Random_Guid    import Random_Guid
-    from osbot_utils.helpers.Safe_Id        import Safe_Id
-    from osbot_utils.helpers.Str_ASCII      import Str_ASCII
-
-    TYPE_SAFE__CONVERT_VALUE__SUPPORTED_TYPES = [Guid, Random_Guid, Safe_Id, Str_ASCII, Timestamp_Now]
-
-    if target is not None and attr_name is not None:
-        if hasattr(target, '__annotations__'):
-            obj_annotations  = target.__annotations__
-            if hasattr(obj_annotations,'get'):
-                attribute_annotation = obj_annotations.get(attr_name)
-                if attribute_annotation:
-                    origin = get_origin(attribute_annotation)                               # Add handling for Type[T] annotations
-                    if origin is type and isinstance(value, str):
-                        try:                                                                # Convert string path to actual type
-                            if len(value.rsplit('.', 1)) > 1:
-                                module_name, class_name = value.rsplit('.', 1)
-                                module = __import__(module_name, fromlist=[class_name])
-                                return getattr(module, class_name)
-                        except (ValueError, ImportError, AttributeError) as e:
-                            raise ValueError(f"Could not convert '{value}' to type: {str(e)}")
-
-                    if attribute_annotation in TYPE_SAFE__CONVERT_VALUE__SUPPORTED_TYPES:          # for now hard-coding this to just these types until we understand the side effects
-                        return attribute_annotation(value)
-    return value
-
 
 def default_value(target : type):
     try:
@@ -358,93 +255,6 @@ def obj_get_value(target=None, key=None, default=None):
 def obj_values(target=None):
     return list(obj_dict(target).values())
 
-def raise_exception_on_obj_type_annotation_mismatch(target, attr_name, value):
-    if value_type_matches_obj_annotation_for_attr(target, attr_name, value) is False:               # handle case with normal types
-        if value_type_matches_obj_annotation_for_union_and_annotated(target, attr_name, value) is True:      # handle union cases
-            return                                                                                  #     this is done like this because value_type_matches_obj_annotation_for_union_attr will return None when there is no Union objects
-        raise TypeError(f"Invalid type for attribute '{attr_name}'. Expected '{target.__annotations__.get(attr_name)}' but got '{type(value)}'")
-
-def obj_attribute_annotation(target, attr_name):
-    if target is not None and attr_name is not None:
-        if hasattr(target, '__annotations__'):
-            obj_annotations  = target.__annotations__
-            if hasattr(obj_annotations,'get'):
-                attribute_annotation = obj_annotations.get(attr_name)
-                return attribute_annotation
-    return None
-
-def obj_is_attribute_annotation_of_type(target, attr_name, expected_type):
-    attribute_annotation = obj_attribute_annotation(target, attr_name)
-    if expected_type is attribute_annotation:
-        return True
-    if expected_type is type(attribute_annotation):
-        return True
-    if expected_type is get_origin(attribute_annotation):                               # handle genericAlias
-        return True
-    return False
-
-def obj_is_type_union_compatible(var_type, compatible_types):
-    from typing import Union
-
-    origin = get_origin(var_type)
-    if isinstance(var_type, _GenericAlias) and origin is type:              # Add handling for Type[T]
-        return type in compatible_types                                     # Allow if 'type' is in compatible types
-    if origin is Union:                                                     # For Union types, including Optionals
-        args = get_args(var_type)                                           # Get the argument types
-        for arg in args:                                                    # Iterate through each argument in the Union
-            if not (arg in compatible_types or arg is type(None)):          # Check if the argument is either in the compatible_types or is type(None)
-                return False                                                # If any arg doesn't meet the criteria, return False immediately
-        return True                                                         # If all args are compatible, return True
-    return var_type in compatible_types or var_type is type(None)           # Check for direct compatibility or type(None) for non-Union types
-
-
-def value_type_matches_obj_annotation_for_union_and_annotated(target, attr_name, value):
-    from osbot_utils.helpers.python_compatibility.python_3_8 import Annotated
-    from typing                                              import Union, get_origin, get_args
-
-    value_type           = type(value)
-    attribute_annotation = obj_attribute_annotation(target, attr_name)
-    origin               = get_origin(attribute_annotation)
-
-    if origin is Union:                                                     # Handle Union types (including Optional)
-        args = get_args(attribute_annotation)
-        return value_type in args
-
-    # todo: refactor the logic below to a separate method (and check for duplicate code with other get_origin usage)
-    if origin is Annotated:                                                # Handle Annotated types
-        args        = get_args(attribute_annotation)
-        base_type   = args[0]                                              # First argument is the base type
-        base_origin = get_origin(base_type)
-
-        if base_origin is None:                                            # Non-container types
-            return isinstance(value, base_type)
-
-        if base_origin in (list, List):                                    # Handle List types
-            if not isinstance(value, list):
-                return False
-            item_type = get_args(base_type)[0]
-            return all(isinstance(item, item_type) for item in value)
-
-        if base_origin in (tuple, Tuple):                                  # Handle Tuple types
-            if not isinstance(value, tuple):
-                return False
-            item_types = get_args(base_type)
-            return len(value) == len(item_types) and all(
-                isinstance(item, item_type)
-                for item, item_type in zip(value, item_types)
-            )
-
-        if base_origin in (dict, Dict):                                    # Handle Dict types
-            if not isinstance(value, dict):
-                return False
-            key_type, value_type = get_args(base_type)
-            return all(isinstance(k, key_type) and isinstance(v, value_type)
-                      for k, v in value.items())
-
-    # todo: add support for for other typing constructs
-    return None                                                             # if it is not a Union or Annotated types just return None (to give an indication to the caller that the comparison was not made)
-
-
 def pickle_save_to_bytes(target: object) -> bytes:
     import pickle
     return pickle.dumps(target)
@@ -457,47 +267,32 @@ def pickle_load_from_bytes(pickled_data: bytes):
         except Exception:
             return {}
 
-def all_annotations(target):
-    annotations = {}
-    if hasattr(target.__class__, '__mro__'):
-        for base in reversed(target.__class__.__mro__):
-            if hasattr(base, '__annotations__'):
-                annotations.update(base.__annotations__)
-    return annotations
-
-def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
-    import typing
-    annotations = all_annotations(target)
-    attr_type   = annotations.get(attr_name)
-    if attr_type:
-        origin_attr_type = get_origin(attr_type)                                    # to handle when type definition contains a generic
-        if origin_attr_type is type:                                                # Add handling for Type[T]
-            type_arg = get_args(attr_type)[0]                                       # Get T from Type[T]
-            if type_arg == value:
-                return True
-            if isinstance(type_arg, (str, ForwardRef)):                             # Handle forward reference
-                type_arg = target.__class__                                         # If it's a forward reference, the target class should be the containing class
-            return isinstance(value, type) and issubclass(value, type_arg)          # Check that value is a type and is subclass of type_arg
-
-        if origin_attr_type is Annotated:                                           # if the type is Annotated
-            args             = get_args(attr_type)
-            origin_attr_type = args[0]
-
-        elif origin_attr_type is typing.Union:
-            args = get_args(attr_type)
-            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] )
-                attr_type = args[0]
-                origin_attr_type = get_origin(attr_type)
-
-        if origin_attr_type:
-            attr_type = origin_attr_type
-        value_type = type(value)
-        if are_types_compatible_for_assigment(source_type=value_type, target_type=attr_type):
-            return True
-        if are_types_magic_mock(source_type=value_type, target_type=attr_type):
-            return True
-        return value_type is attr_type
-    return None
+# todo: see if it is possible to add recursive protection to this logic
+def serialize_to_dict(obj):
+    from decimal import Decimal
+    from enum    import Enum
+    from typing  import List
+
+    if isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:
+        return obj
+    elif isinstance(obj, Enum):
+        return obj.name
+    elif isinstance(obj, type):
+        return f"{obj.__module__}.{obj.__name__}"                                   # save the full type name
+    elif isinstance(obj, list) or isinstance(obj, List):
+        return [serialize_to_dict(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {key: serialize_to_dict(value) for key, value in obj.items()}
+    elif hasattr(obj, "__dict__"):
+        data = {}                                                                   # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
+        for key, value in obj.__dict__.items():
+            if key.startswith('__') is False:                                       # don't process internal variables (for example the ones set by @cache_on_self)
+                data[key] = serialize_to_dict(value)                                # Recursive call for complex types
+        return data
+    else:
+        raise TypeError(f"Type {type(obj)} not serializable")
+
+
 
 
 

osbot_utils/utils/Status.py

@@ -1,6 +1,4 @@
 # todo refactor into Status class
-import traceback
-
 from osbot_utils.utils.Python_Logger import Python_Logger
 
 class Status:

osbot_utils/version

@@ -1 +1 @@
-v2.10.0
+v2.12.0