osbot-utils 2.85.0__tar.gz → 2.87.0__tar.gz

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.85.0
+Version: 2.87.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.85.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.87.0-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-2.85.0 → osbot_utils-2.87.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.85.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.87.0-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-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/Type_Safe.py

@@ -1,8 +1,8 @@
 # todo: find a way to add these documentations strings to a separate location so that
 #       the data is available in IDE's code complete
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Validation import type_safe_validation
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Validation          import type_safe_validation
 from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Class_Kwargs   import type_safe_step_class_kwargs
-from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Default_Kwargs  import type_safe_step_default_kwargs
+from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Default_Kwargs import type_safe_step_default_kwargs
 from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Default_Value  import type_safe_step_default_value
 from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Init           import type_safe_step_init
 from osbot_utils.type_safe.type_safe_core.steps.Type_Safe__Step__Set_Attr       import type_safe_step_set_attr

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/Type_Safe__Primitive.py

@@ -67,4 +67,9 @@ class Type_Safe__Primitive:
         if self.__primitive_base__ is str:
             return f"{type(self).__name__}('{value_str}')"
         else:
-            return f"{type(self).__name__}({value_str})"
+            return f"{type(self).__name__}({value_str})"
+
+    def __to_primitive__(self):                                     # Convert this Type_Safe__Primitive instance to its base primitive type.
+        if self.__primitive_base__:
+            return self.__primitive_base__(self)
+        return str(self)                                            # fallback

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/primitives/safe_str/identifiers/Random_Guid_Short.py

@@ -1,8 +1,8 @@
-# todo add to osbot utils
-from osbot_utils.utils.Misc import random_guid_short
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+from osbot_utils.utils.Misc                     import random_guid_short
 
 
-class Random_Guid_Short(str):
+class Random_Guid_Short(Type_Safe__Primitive, str):
     def __new__(cls, value=None):
         if value is None:
             value = random_guid_short()

osbot_utils-2.87.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -0,0 +1,83 @@
+from typing                                                           import Type
+from osbot_utils.testing.__                                           import __
+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.collections.Type_Safe__List import Type_Safe__List
+from osbot_utils.utils.Objects                                        import dict_to_obj
+
+
+class Type_Safe__Dict(Type_Safe__Base, dict):
+    def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.expected_key_type   = expected_key_type
+        self.expected_value_type = expected_value_type
+
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)                                     # First try direct lookup
+        except KeyError:
+            converted_key = self.try_convert(key, self.expected_key_type)       # Try converting the key
+            return super().__getitem__(converted_key)                           # and compare again
+
+    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 json(self):
+        from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+        def serialize_value(v):
+            """Recursively serialize values, handling nested structures"""
+            if isinstance(v, Type_Safe):
+                return v.json()
+            elif isinstance(v, Type_Safe__Primitive):
+                return v.__to_primitive__()
+            elif isinstance(v, dict):
+                # Recursively handle nested dictionaries
+                return {k2: serialize_value(v2) for k2, v2 in v.items()}
+            elif isinstance(v, (list, tuple, set)):
+                # Recursively handle sequences
+                serialized = [serialize_value(item) for item in v]
+                if isinstance(v, list):
+                    return serialized
+                elif isinstance(v, tuple):
+                    return tuple(serialized)
+                else:  # set
+                    return set(serialized)
+            else:
+                return v
+
+        result = {}
+        for key, value in self.items():
+            # Handle Type objects as keys
+            if isinstance(key, (type, Type)):
+                key = f"{key.__module__}.{key.__name__}"
+            elif isinstance(key, Type_Safe__Primitive):
+                key = key.__to_primitive__()
+
+            # Use recursive serialization for values
+            result[key] = serialize_value(value)
+
+        return result
+
+    def get(self, key, default=None):       # this makes it consistent with the modified behaviour of __get__item
+        try:
+            return self[key]                # Use __getitem__ with conversion
+        except KeyError:
+            return default                  # Return default instead of raising
+
+    def keys(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_key_type, super().keys())
+
+    def obj(self) -> __:
+        return dict_to_obj(self.json())
+
+    def values(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_value_type, super().values())

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py

@@ -50,6 +50,8 @@ class Type_Safe__List(Type_Safe__Base, list):
         for item in self:
             if isinstance(item, Type_Safe):
                 result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())
             elif isinstance(item, (list, tuple)):
                 result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
             elif isinstance(item, dict):

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py

@@ -1,4 +1,6 @@
-from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
+from osbot_utils.type_safe.Type_Safe__Base      import Type_Safe__Base, type_str
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
 
 class Type_Safe__Set(Type_Safe__Base, set):
     def __init__(self, expected_type, *args):
@@ -10,10 +12,21 @@ class Type_Safe__Set(Type_Safe__Base, set):
         return f"set[{expected_type_name}] with {len(self)} elements"
 
     def add(self, item):
-        try:
+        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:       # Handle Type_Safe objects from dicts
+            item = self.expected_type.from_json(item)
+        elif type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe__Primitive):                 # Handle Type_Safe__Primitive conversions (str -> Safe_Str, etc.)
+            if not isinstance(item, self.expected_type):
+                try:
+                    item = self.expected_type(item)
+                except (ValueError, TypeError) as e:
+                    raise TypeError(f"In Type_Safe__Set: Could not convert {type(item).__name__} to {self.expected_type.__name__}: {e}") from None
+
+        try:                                                                                                            # Now validate the (possibly converted) item
             self.is_instance_of_type(item, self.expected_type)
         except TypeError as e:
-            raise TypeError(f"In Type_Safe__Set: Invalid type for item: {e}")
+            raise TypeError(f"In Type_Safe__Set: Invalid type for item: {e}") from None
+
         super().add(item)
 
     def json(self):
@@ -23,6 +36,8 @@ class Type_Safe__Set(Type_Safe__Base, set):
         for item in self:
             if isinstance(item, Type_Safe):
                 result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())
             elif isinstance(item, (list, tuple, set)):
                 result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
             elif isinstance(item, dict):

osbot_utils-2.87.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -0,0 +1,74 @@
+from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
+
+class Type_Safe__Tuple(Type_Safe__Base, tuple):
+
+    def __new__(cls, expected_types, items=None):
+        items = items or tuple()
+
+        converted_items = cls.convert_items(expected_types, items)                  # Convert items BEFORE creating the tuple
+
+        instance = super().__new__(cls, converted_items)
+        instance.expected_types = expected_types
+        return instance
+
+    def __init__(self, expected_types, items=None):
+        if items:
+            self.validate_items(self)                                               # Validate the already-converted items
+
+    @classmethod
+    def convert_items(cls, expected_types, items):                                  # Convert items to expected types before creating the tuple.
+        from osbot_utils.type_safe.Type_Safe            import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
+        if not items:
+            return tuple()
+
+        if len(items) != len(expected_types):
+            raise ValueError(f"Expected {len(expected_types)} elements, got {len(items)}")
+
+
+        converted = []
+        for item, expected_type in zip(items, expected_types):
+            if type(expected_type) is type and issubclass(expected_type, Type_Safe) and type(item) is dict: # Handle Type_Safe objects from dicts
+                item = expected_type.from_json(item)
+            elif type(expected_type) is type and issubclass(expected_type, Type_Safe__Primitive):           # Handle Type_Safe__Primitive conversions
+                if not isinstance(item, expected_type):
+                    try:
+                        item = expected_type(item)
+                    except (ValueError, TypeError) as e:
+                        raise TypeError(f"In Type_Safe__Tuple: Could not convert {type(item).__name__} to {expected_type.__name__}: {e}") from None
+
+            converted.append(item)
+
+        return tuple(converted)
+
+    def validate_items(self, items):
+        if len(items) != len(self.expected_types):
+            raise ValueError(f"Expected {len(self.expected_types)} elements, got {len(items)}")
+        for item, expected_type in zip(items, self.expected_types):
+            try:
+                self.is_instance_of_type(item, expected_type)
+            except TypeError as e:
+                raise TypeError(f"In Type_Safe__Tuple: Invalid type for item: {e}")
+
+    def __repr__(self):
+        types_str = ', '.join(type_str(t) for t in self.expected_types)
+        return f"tuple[{types_str}] with {len(self)} elements"
+
+    def json(self):
+        from osbot_utils.type_safe.Type_Safe            import Type_Safe
+        from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
+        result = []
+        for item in self:
+            if isinstance(item, Type_Safe):
+                result.append(item.json())
+            elif isinstance(item, Type_Safe__Primitive):
+                result.append(item.__to_primitive__())  # Convert primitives to base types
+            elif isinstance(item, (list, tuple)):
+                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
+            elif isinstance(item, dict):
+                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
+            else:
+                result.append(item)
+        return result

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -5,17 +5,18 @@ from enum
 from osbot_utils.helpers.Obj_Id                                                   import Obj_Id
 from osbot_utils.type_safe.Type_Safe                                              import Type_Safe
 from osbot_utils.type_safe.primitives.safe_str.identifiers.Random_Guid            import Random_Guid
-from osbot_utils.type_safe.primitives.safe_str.identifiers.Random_Guid_Short                                        import Random_Guid_Short
+from osbot_utils.type_safe.primitives.safe_str.identifiers.Random_Guid_Short      import Random_Guid_Short
 from osbot_utils.type_safe.primitives.safe_str.cryptography.hashes.Safe_Str__Hash import Safe_Str__Hash
 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.collections.Type_Safe__Set              import Type_Safe__Set
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Tuple            import Type_Safe__Tuple
 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__Cache                 import type_safe_cache
 from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Convert               import type_safe_convert
 from osbot_utils.utils.Objects                                                    import enum_from_value
 from osbot_utils.type_safe.primitives.safe_str.identifiers.Safe_Id                import Safe_Id
-from osbot_utils.type_safe.primitives.safe_int.Timestamp_Now                       import Timestamp_Now
+from osbot_utils.type_safe.primitives.safe_int.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
@@ -60,8 +61,11 @@ class Type_Safe__Step__From_Json:
                     elif annotation_origin == type:                                         # Handle type objects inside ForwardRef
                         value = self.deserialize_type__using_value(value)
                     if annotation_origin is tuple and isinstance(value, list):
-                        # item_types = get_args(annotation)   # todo: see if we should do type safety here
-                        value = tuple(value)
+                        item_types = get_args(annotation)
+                        if item_types:
+                            value = Type_Safe__Tuple(expected_types=item_types, items=value)                # Create a Type_Safe__Tuple with proper type conversion
+                        else:
+                            value = tuple(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, set):                              # handle the case when the value is a list

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -13,6 +13,8 @@ class Type_Safe__Step__Set_Attr:
             value = self.resolve_value__dict(_self, name, value)
         elif type(value) is list:
             value = self.resolve_value__list(_self, name, value)
+        elif type(value) is tuple:
+            value = self.resolve_value__tuple(_self, name, value)
         elif isinstance(annotations.get(name), type) and issubclass(annotations.get(name), Type_Safe__Primitive) and type(value) in (int, str, float):
             return annotations.get(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)
@@ -53,6 +55,20 @@ class Type_Safe__Step__Set_Attr:
                     return type_safe_list
 
         return value
+
+    def resolve_value__tuple(self, _self, name, value):                 # Convert regular tuples to Type_Safe__Tuple instances
+        annotations = type_safe_cache.get_obj_annotations(_self)
+        annotation = annotations.get(name)
+
+        if annotation:
+            origin = type_safe_cache.get_origin(annotation)
+            if origin is tuple:
+                args = get_args(annotation)
+                if args:
+                    from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__Tuple import Type_Safe__Tuple
+                    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)
@@ -106,7 +122,7 @@ class Type_Safe__Step__Set_Attr:
             return _super.__setattr__(name, value)
 
         if value is not None:
-            value = self.resolve_value          (_self, annotations, name, value)
+            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)

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/osbot_utils/utils/Objects.py

@@ -265,14 +265,18 @@ def pickle_load_from_bytes(pickled_data: bytes):
             return {}
 
 # todo: see if it is possible to add recursive protection to this logic
+# todo: we should move this method to the type_safe classes and folders
 def serialize_to_dict(obj):
-    from decimal import Decimal
-    from enum    import Enum
-    from typing  import List
-
-    if hasattr(obj, '__primitive_base__') and isinstance(obj, (str, int, float)):
+    from decimal                               import Decimal
+    from enum                                  import Enum
+    from typing                                import List
+    from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
+
+    if isinstance(obj, Type_Safe__Base) and hasattr(obj, 'json'):                                   # if it is one of these Type_Safe__Base  classes
+        return obj.json()                                                                           #   use the provided .json() method, which handles the type conversions more specifically to those types (dict, list, set and tuple)
+    elif hasattr(obj, '__primitive_base__') and isinstance(obj, (str, int, float)):
         return obj.__primitive_base__(obj)
-    elif isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:     # todo: add support for objects like datetime
+    elif isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:                # todo: add support for objects like datetime
         return obj
     elif isinstance(obj, Enum):
         return obj.name

osbot_utils-2.87.0/osbot_utils/version

@@ -0,0 +1 @@
+v2.87.0

{osbot_utils-2.85.0 → osbot_utils-2.87.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v2.85.0"
+version     = "v2.87.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-2.85.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -1,55 +0,0 @@
-from typing                                                           import Type
-from osbot_utils.type_safe.Type_Safe__Base                            import Type_Safe__Base
-from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
-
-
-class Type_Safe__Dict(Type_Safe__Base, dict):
-    def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.expected_key_type   = expected_key_type
-        self.expected_value_type = expected_value_type
-
-    def __getitem__(self, key):
-        try:
-            return super().__getitem__(key)                                     # First try direct lookup
-        except KeyError:
-            converted_key = self.try_convert(key, self.expected_key_type)       # Try converting the key
-            return super().__getitem__(converted_key)                           # and compare again
-
-    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 json(self):                                                                         # Convert the dictionary to a JSON-serializable format.
-        from osbot_utils.type_safe.Type_Safe import Type_Safe                               # can only import this here to avoid circular imports
-
-        result = {}
-        for key, value in self.items():
-
-            if isinstance(key, (type, Type)):                                                     # Handle Type objects as keys
-                key = f"{key.__module__}.{key.__name__}"
-
-            if isinstance(value, Type_Safe):                                                # Handle Type_Safe objects in values
-                result[key] = value.json()
-            elif isinstance(value, (list, tuple)):                                          # Handle lists/tuples that might contain Type_Safe objects
-                result[key] = [item.json() if isinstance(item, Type_Safe) else item
-                               for item in value]
-            elif isinstance(value, dict):                                                   # Handle nested dictionaries that might contain Type_Safe objects
-                result[key] = {k: v.json() if isinstance(v, Type_Safe) else v
-                               for k, v in value.items()}
-            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-2.85.0/osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -1,41 +0,0 @@
-from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
-
-class Type_Safe__Tuple(Type_Safe__Base, tuple):
-
-    def __new__(cls, expected_types, items=None):
-        items    = items or tuple()
-        instance = super().__new__(cls, items)
-        instance.expected_types = expected_types
-        return instance
-
-    def __init__(self, expected_types, items=None):             # todo: see if we should be assigning expected_types to self here
-        if items:
-            self.validate_items(items)
-
-    def validate_items(self, items):
-        if len(items) != len(self.expected_types):
-            raise ValueError(f"Expected {len(self.expected_types)} elements, got {len(items)}")
-        for item, expected_type in zip(items, self.expected_types):
-            try:
-                self.is_instance_of_type(item, expected_type)
-            except TypeError as e:
-                raise TypeError(f"In Type_Safe__Tuple: Invalid type for item: {e}")
-
-    def __repr__(self):
-        types_str = ', '.join(type_str(t) for t in self.expected_types)
-        return f"tuple[{types_str}] with {len(self)} elements"
-
-    def json(self):
-        from osbot_utils.type_safe.Type_Safe import Type_Safe
-
-        result = []
-        for item in self:
-            if isinstance(item, Type_Safe):
-                result.append(item.json())
-            elif isinstance(item, (list, tuple)):
-                result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])
-            elif isinstance(item, dict):
-                result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
-            else:
-                result.append(item)
-        return result

osbot_utils-2.85.0/osbot_utils/version

@@ -1 +0,0 @@
-v2.85.0