osbot-utils 1.88.0__py3-none-any.whl → 1.89.0__py3-none-any.whl

osbot_utils/base_classes/Type_Safe.py

@@ -3,7 +3,7 @@
 
 import sys
 import types
-from osbot_utils.utils.Objects import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
+from osbot_utils.utils.Objects                  import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -23,7 +23,7 @@ if sys.version_info < (3, 8):                                           # pragma
         else:
             return ()
 else:
-    from typing import get_origin, get_args
+    from typing import get_origin, get_args, ForwardRef
 
 if sys.version_info >= (3, 10):
     NoneType = types.NoneType
@@ -148,6 +148,7 @@ class Type_Safe:
     def __default__value__(cls, var_type):
         import typing
         from osbot_utils.base_classes.Type_Safe__List import Type_Safe__List
+        from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
 
         if var_type is typing.Set:                              # todo: refactor the dict, set and list logic, since they are 90% the same
             return set()
@@ -156,13 +157,28 @@ class Type_Safe:
 
         if var_type is typing.Dict:
             return {}
-        if get_origin(var_type) is dict:
-            return {}                                           # todo: add Type_Safe__Dict
+
+        if get_origin(var_type) 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
+            return []                                           # handle case when List was used with no type information provided
+
         if get_origin(var_type) 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
@@ -258,16 +274,16 @@ class Type_Safe:
         return self
 
     def deserialize_dict__using_key_value_annotations(self, key, value):
+        from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
+
         dict_annotations_tuple =  get_args(self.__annotations__[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   = get_args(self.__annotations__[key])[0]
-        #value_class = get_args(self.__annotations__[key])[1]
         key_class   = dict_annotations_tuple[0]
         value_class = dict_annotations_tuple[1]
-        new_value   = {}
+        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):

osbot_utils/base_classes/Type_Safe__Base.py

@@ -0,0 +1,117 @@
+from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+
+EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
+
+class Type_Safe__Base:
+    def is_instance_of_type(self, item, expected_type):
+        if expected_type is Any:
+            return True
+        if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
+            return True
+        origin = get_origin(expected_type)
+        args   = get_args(expected_type)
+        if origin is None:
+            if expected_type in EXACT_TYPE_MATCH:
+                if type(item) is expected_type:
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            else:
+                if isinstance(item, expected_type):                                 # Non-parameterized type
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name   = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+        elif origin is list and args:                                                    # Expected type is List[...]
+            (item_type,) = args
+            if not isinstance(item, list):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for idx, elem in enumerate(item):
+                try:
+                    self.is_instance_of_type(elem, item_type)
+                except TypeError as e:
+                    raise TypeError(f"In list at index {idx}: {e}")
+            return True
+        elif origin is dict and args:                                                    # Expected type is Dict[...]
+            key_type, value_type = args
+            if not isinstance(item, dict):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for k, v in item.items():
+                try:
+                    self.is_instance_of_type(k, key_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict key '{k}': {e}")
+                try:
+                    self.is_instance_of_type(v, value_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict value for key '{k}': {e}")
+            return True
+        elif origin is tuple:
+            if not isinstance(item, tuple):
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            if len(args) != len(item):
+                raise TypeError(f"Expected tuple of length {len(args)}, but got {len(item)}")
+            for idx, (elem, elem_type) in enumerate(zip(item, args)):
+                try:
+                    self.is_instance_of_type(elem, elem_type)
+                except TypeError as e:
+                    raise TypeError(f"In tuple at index {idx}: {e}")
+            return True
+        elif origin is Union or expected_type is Optional:                                                   # Expected type is Union[...]
+            for arg in args:
+                try:
+                    self.is_instance_of_type(item, arg)
+                    return True
+                except TypeError:
+                    continue
+            expected_type_name = type_str(expected_type)
+            actual_type_name   = type_str(type(item))
+            raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+        else:
+            if isinstance(item, origin):
+                return True
+            else:
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+# todo: see if we should/can move this to the Objects.py file
+def type_str(tp):
+    origin = get_origin(tp)
+    if origin is None:
+        if hasattr(tp, '__name__'):
+            return tp.__name__
+        else:
+            return str(tp)
+    else:
+        args = get_args(tp)
+        args_str = ', '.join(type_str(arg) for arg in args)
+        return f"{origin.__name__}[{args_str}]"
+
+def get_object_type_str(obj):
+    if isinstance(obj, dict):
+        if not obj:
+            return "Dict[Empty]"
+        key_types      = set(type(k).__name__ for k in obj.keys())
+        value_types    = set(type(v).__name__ for v in obj.values())
+        key_type_str   = ', '.join(sorted(key_types))
+        value_type_str = ', '.join(sorted(value_types))
+        return f"Dict[{key_type_str}, {value_type_str}]"
+    elif isinstance(obj, list):
+        if not obj:
+            return "List[Empty]"
+        elem_types = set(type(e).__name__ for e in obj)
+        elem_type_str = ', '.join(sorted(elem_types))
+        return f"List[{elem_type_str}]"
+    else:
+        return type(obj).__name__

osbot_utils/base_classes/Type_Safe__Dict.py

@@ -0,0 +1,22 @@
+from osbot_utils.base_classes.Type_Safe__Base import type_str, Type_Safe__Base
+
+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
+
+        for k, v in self.items():                           # check type-safety of ctor arguments
+            self.is_instance_of_type(k, self.expected_key_type  )
+            self.is_instance_of_type(v, self.expected_value_type)
+
+    def __setitem__(self, key, value):                                  # Check type-safety before allowing assignment.
+        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 __repr__(self):
+        key_type_name   = type_str(self.expected_key_type)
+        value_type_name = type_str(self.expected_value_type)
+        return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"

osbot_utils/base_classes/Type_Safe__List.py

@@ -1,8 +1,7 @@
-from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+from osbot_utils.base_classes.Type_Safe__Base import Type_Safe__Base, type_str
 
-EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
 
-class Type_Safe__List(list):
+class Type_Safe__List(Type_Safe__Base, list):
 
     def __init__(self, expected_type, *args):
         super().__init__(*args)
@@ -19,115 +18,5 @@ class Type_Safe__List(list):
             raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}")
         super().append(item)
 
-    def is_instance_of_type(self, item, expected_type):
-        if expected_type is Any:
-            return True
-        if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
-            return True
-        origin = get_origin(expected_type)
-        args   = get_args(expected_type)
-        if origin is None:
-            if expected_type in EXACT_TYPE_MATCH:
-                if type(item) is expected_type:
-                    return True
-                else:
-                    expected_type_name = type_str(expected_type)
-                    actual_type_name = type_str(type(item))
-                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            else:
-                if isinstance(item, expected_type):                                 # Non-parameterized type
-                    return True
-                else:
-                    expected_type_name = type_str(expected_type)
-                    actual_type_name   = type_str(type(item))
-                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-        elif origin is list and args:                                                    # Expected type is List[...]
-            (item_type,) = args
-            if not isinstance(item, list):
-                expected_type_name = type_str(expected_type)
-                actual_type_name   = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            for idx, elem in enumerate(item):
-                try:
-                    self.is_instance_of_type(elem, item_type)
-                except TypeError as e:
-                    raise TypeError(f"In list at index {idx}: {e}")
-            return True
-        elif origin is dict and args:                                                    # Expected type is Dict[...]
-            key_type, value_type = args
-            if not isinstance(item, dict):
-                expected_type_name = type_str(expected_type)
-                actual_type_name   = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            for k, v in item.items():
-                try:
-                    self.is_instance_of_type(k, key_type)
-                except TypeError as e:
-                    raise TypeError(f"In dict key '{k}': {e}")
-                try:
-                    self.is_instance_of_type(v, value_type)
-                except TypeError as e:
-                    raise TypeError(f"In dict value for key '{k}': {e}")
-            return True
-        elif origin is tuple:
-            if not isinstance(item, tuple):
-                expected_type_name = type_str(expected_type)
-                actual_type_name = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-            if len(args) != len(item):
-                raise TypeError(f"Expected tuple of length {len(args)}, but got {len(item)}")
-            for idx, (elem, elem_type) in enumerate(zip(item, args)):
-                try:
-                    self.is_instance_of_type(elem, elem_type)
-                except TypeError as e:
-                    raise TypeError(f"In tuple at index {idx}: {e}")
-            return True
-        elif origin is Union or expected_type is Optional:                                                   # Expected type is Union[...]
-            for arg in args:
-                try:
-                    self.is_instance_of_type(item, arg)
-                    return True
-                except TypeError:
-                    continue
-            expected_type_name = type_str(expected_type)
-            actual_type_name   = type_str(type(item))
-            raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
-        else:
-            if isinstance(item, origin):
-                return True
-            else:
-                expected_type_name = type_str(expected_type)
-                actual_type_name = type_str(type(item))
-                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-# todo: see if we should/can move this to the Objects.py file
-def type_str(tp):
-    origin = get_origin(tp)
-    if origin is None:
-        if hasattr(tp, '__name__'):
-            return tp.__name__
-        else:
-            return str(tp)
-    else:
-        args = get_args(tp)
-        args_str = ', '.join(type_str(arg) for arg in args)
-        return f"{origin.__name__}[{args_str}]"
-
-def get_object_type_str(obj):
-    if isinstance(obj, dict):
-        if not obj:
-            return "Dict[Empty]"
-        key_types      = set(type(k).__name__ for k in obj.keys())
-        value_types    = set(type(v).__name__ for v in obj.values())
-        key_type_str   = ', '.join(sorted(key_types))
-        value_type_str = ', '.join(sorted(value_types))
-        return f"Dict[{key_type_str}, {value_type_str}]"
-    elif isinstance(obj, list):
-        if not obj:
-            return "List[Empty]"
-        elem_types = set(type(e).__name__ for e in obj)
-        elem_type_str = ', '.join(sorted(elem_types))
-        return f"List[{elem_type_str}]"
-    else:
-        return type(obj).__name__

osbot_utils/helpers/Xml_To_Dict.py

@@ -0,0 +1,87 @@
+from typing                 import Dict, Any, Union
+from xml.etree.ElementTree  import Element
+
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+class XML_Attribute(Type_Safe):
+    name     : str
+    value    : str
+    namespace: str
+
+class XML_Element(Type_Safe):
+    attributes: Dict[str, XML_Attribute]
+    children  : Dict[str, Union[str, 'XML_Element']]
+
+
+class Xml_To_Dict(Type_Safe):
+    xml_data    : str             = None       # Input XML string
+    root        : Element         = None       # Root ElementTree.Element
+    namespaces  : Dict[str, str]               # XML namespaces
+    xml_dict    : Dict[str, Any]               # Parsed XML as dictionary
+
+    def setup(self) :
+        from xml.etree.ElementTree import ParseError
+        try:
+            self.load_namespaces()
+            self.load_root()
+
+        except ParseError as e:
+            raise ValueError(f"Invalid XML: {str(e)}")
+        return self
+
+
+    def load_namespaces(self):
+        from xml.etree.ElementTree import iterparse
+        from io import StringIO
+
+        for event, elem in iterparse(StringIO(self.xml_data), events=("start-ns",)):
+            self.namespaces[elem[0]] = elem[1]
+
+    def load_root(self):
+        from xml.etree.ElementTree import fromstring
+
+        self.root = fromstring(self.xml_data)
+
+    def element_to_dict(self, element: Element) -> Union[Dict[str, Any], str]:
+        """Convert an ElementTree.Element to a dictionary"""
+        result: Dict[str, Any] = {}
+
+
+        if element.attrib:                                  # Handle attributes
+            result.update(element.attrib)
+
+        # Handle child elements
+        child_nodes: Dict[str, Any] = {}
+        for child in element:
+            tag = child.tag                                 # Remove namespace prefix if present
+            if '}' in tag:
+                tag = tag.split('}', 1)[1]
+
+            child_data = self.element_to_dict(child)
+
+            if tag in child_nodes:
+                if not isinstance(child_nodes[tag], list):
+                    child_nodes[tag] = [child_nodes[tag]]
+                child_nodes[tag].append(child_data)
+            else:
+                child_nodes[tag] = child_data
+
+        # Handle text content
+        text = element.text.strip() if element.text else ''
+        if text:
+            if child_nodes or result:
+                result['_text'] = text
+            else:
+                return text
+        elif not child_nodes and not result:                # Make sure we return text content even for empty nodes
+            return text
+
+        # Combine results
+        if child_nodes:
+            result.update(child_nodes)
+
+        return result
+
+    def parse(self) -> Dict[str, Any]:   # Convert parsed XML to dictionary
+        self.xml_dict = self.element_to_dict(self.root)
+        return self

osbot_utils/utils/Objects.py

@@ -30,14 +30,17 @@ 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
+    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
+    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
@@ -413,7 +416,7 @@ def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
                 origin_attr_type = get_origin(attr_type)                # to handle when type definion contains an generic
                 if 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 (whcih is an shorthand for Union[X, None] )
+                    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)
 

osbot_utils/version

@@ -1 +1 @@
-v1.88.0
+v1.89.0

{osbot_utils-1.88.0.dist-info → osbot_utils-1.89.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.88.0
+Version: 1.89.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.88.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.89.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.88.0.dist-info → osbot_utils-1.89.0.dist-info}/RECORD

@@ -2,8 +2,10 @@ osbot_utils/__init__.py,sha256=DdJDmQc9zbQUlPVyTJOww6Ixrn9n4bD3ami5ItQfzJI,16
 osbot_utils/base_classes/Cache_Pickle.py,sha256=kPCwrgUbf_dEdxUz7vW1GuvIPwlNXxuRhb-H3AbSpII,5884
 osbot_utils/base_classes/Kwargs_To_Disk.py,sha256=HHoy05NC_w35WcT-OnSKoSIV_cLqaU9rdjH0_KNTM0E,1096
 osbot_utils/base_classes/Kwargs_To_Self.py,sha256=weFNsBfBNV9W_qBkN-IdBD4yYcJV_zgTxBRO-ZlcPS4,141
-osbot_utils/base_classes/Type_Safe.py,sha256=VeNkr6BD9iA9LyQ2FiduHIMM8nS0iaALpwYC2Y-KWy4,23445
-osbot_utils/base_classes/Type_Safe__List.py,sha256=iWyoc2xjHkTJrZTVnPse9Rljte2tF67oNq8yA7jnAhY,5996
+osbot_utils/base_classes/Type_Safe.py,sha256=oEwxNPa1pcq6ccJUyWPUuuMXK6CRzVIzwQNL2lcc6E4,24663
+osbot_utils/base_classes/Type_Safe__Base.py,sha256=CFPYe8_i5vvTLyc7s8CXbY4n_dY6sqVfBY8w9Vo77ZA,5468
+osbot_utils/base_classes/Type_Safe__Dict.py,sha256=sfZcukhXUd9TS0PQpAk-gGLfZUJSC6BtMh6jF4Fn8Jw,1107
+osbot_utils/base_classes/Type_Safe__List.py,sha256=pXDzJJttpEQQ9oTdsw7BykMB4VIX2rZzi1ZrnCzMZ8M,650
 osbot_utils/base_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/async_invoke.py,sha256=-ja3K8orLy8Of54CIYSK-zn443pOIDY2hnFBjVELrXc,829
@@ -75,6 +77,7 @@ osbot_utils/helpers/Str_ASCII.py,sha256=PRqyu449XnKrLn6b9Miii1Hv-GO5OAa1UhhgvlRc
 osbot_utils/helpers/Timestamp_Now.py,sha256=k3-SUGYx2jLTXvgZYeECqPRJhVxqWPmW7co1l6r12jk,438
 osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbGuEN3S94,311
 osbot_utils/helpers/Type_Safe_Method.py,sha256=8E88of__An9_ZhJKz6Kp22C1mb9WLED0jWNLOII3fJs,10489
+osbot_utils/helpers/Xml_To_Dict.py,sha256=EbuiLi1cElakYyueSKi6LKJXUDz4-oi4QTFI1WTu7Rs,2846
 osbot_utils/helpers/Zip_Bytes.py,sha256=KB5zWfCf6ET4alNfqNrSp5DxZ3Jp9oDHpc6tK2iO_qg,4320
 osbot_utils/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/ast/Ast.py,sha256=lcPQOSxXI6zgmMnIVF9WM6ISqViWX-sq4d_UC0CDG8s,1155
@@ -303,7 +306,7 @@ osbot_utils/utils/Json.py,sha256=0DZGlCU7Nqte5n0r7ctPXFybqA5MRfSrTz5zuK_6UFk,709
 osbot_utils/utils/Json_Cache.py,sha256=mLPkkDZN-3ZVJiDvV1KBJXILtKkTZ4OepzOsDoBPhWg,2006
 osbot_utils/utils/Lists.py,sha256=tPz5x5s3sRO97WZ_nsxREBPC5cwaHrhgaYBhsrffTT8,5599
 osbot_utils/utils/Misc.py,sha256=H_xexJgiTxB3jDeDiW8efGQbO0Zuy8MM0iQ7qXC92JI,17363
-osbot_utils/utils/Objects.py,sha256=iuNNp_u9aOiHtAXwkSo-8FikXWcqZczaZqNwHKKQEcM,19617
+osbot_utils/utils/Objects.py,sha256=qzdwfQZMyI-ySlOhuUM6z2M4cW9eZDXpUeTIzgYwlS4,19977
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=tx8N6wRKL3RDHboDRKZn8SirSJdSAE9cACyJkxrThZ8,12792
@@ -315,8 +318,8 @@ osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,166
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=pR6sKliUY0KZXmqNzKY2frfW-YVQEVbLKiyqQX_lc-8,14052
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=D0MVxZOCQlRSLSl_5l6QLAIYIlH9b7vBFCZn_V3Z2WY,8
-osbot_utils-1.88.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-1.88.0.dist-info/METADATA,sha256=KAjZ52Wxr8Kq06sTXHWU8RzvgSGltoSiT7BWLDPKTRg,1317
-osbot_utils-1.88.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-osbot_utils-1.88.0.dist-info/RECORD,,
+osbot_utils/version,sha256=ty30vvmdD1qw-8a6mVUfcEOT_nStazbsrdXwAHaom5k,8
+osbot_utils-1.89.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-1.89.0.dist-info/METADATA,sha256=fqPYnTXYJMDtR982ODsggiUxzZHnnLBFCaBpnOMtpKw,1317
+osbot_utils-1.89.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+osbot_utils-1.89.0.dist-info/RECORD,,