osbot-utils 2.85.0__py3-none-any.whl → 2.86.0__py3-none-any.whl

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/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -1,5 +1,6 @@
 from typing                                                           import Type
 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
 
 
@@ -35,7 +36,8 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
 
             if isinstance(key, (type, Type)):                                                     # Handle Type objects as keys
                 key = f"{key.__module__}.{key.__name__}"
-
+            elif isinstance(key, Type_Safe__Primitive):
+                key = key.__to_primitive__()
             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
@@ -44,8 +46,11 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
             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
+            else:
+                if isinstance(value, Type_Safe__Primitive):
+                    result[key] = value.__to_primitive__()
+                else:
+                    result[key] = value
         return result
 
     def keys(self) -> Type_Safe__List:

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/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__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/type_safe/type_safe_core/collections/Type_Safe__Tuple.py

@@ -3,14 +3,44 @@ 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)
+        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):             # todo: see if we should be assigning expected_types to self here
+    def __init__(self, expected_types, items=None):
         if items:
-            self.validate_items(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):
@@ -26,12 +56,15 @@ class Type_Safe__Tuple(Type_Safe__Base, tuple):
         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            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):

osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py

@@ -10,6 +10,7 @@ from osbot_utils.type_safe.primitives.safe_str.cryptography.hashes.Safe_Str__Has
 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
@@ -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/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/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/version

@@ -1 +1 @@
-v2.85.0
+v2.86.0

{osbot_utils-2.85.0.dist-info → osbot_utils-2.86.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.85.0
+Version: 2.86.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.86.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.dist-info → osbot_utils-2.86.0.dist-info}/RECORD

@@ -351,7 +351,7 @@ osbot_utils/testing/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 osbot_utils/testing/test_data/const__test__data__html.py,sha256=_DmA7OoCwvl1xxxn2aS8mfvf3Ct4bOt1KTUyTDqtwaQ,1718
 osbot_utils/type_safe/Type_Safe.py,sha256=G0HCBk52ehaJGhLYnt4cKUBsqfnxyRDxrY7_7YhktZg,6390
 osbot_utils/type_safe/Type_Safe__Base.py,sha256=cui8fIzUGaPsb-fnANj8nw9cYrVikdx1XZ8in3Y_-QU,9174
-osbot_utils/type_safe/Type_Safe__Primitive.py,sha256=-GBUcuFBBBKrVRSf7cmjPRbAxo7vnL4tOvr9ktmbVj4,3829
+osbot_utils/type_safe/Type_Safe__Primitive.py,sha256=Eufm1CSenInqW8gAgULhUAXV_lMmA4UY4A5U9v8qmnU,4135
 osbot_utils/type_safe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/primitives/safe_float/Safe_Float.py,sha256=qgmO8S8wFHXA4O3hm4bdamFZ0HkaN_r59hSbUNevHhc,6687
@@ -411,10 +411,10 @@ osbot_utils/type_safe/primitives/safe_uint/Safe_UInt__Percentage.py,sha256=MKD2A
 osbot_utils/type_safe/primitives/safe_uint/Safe_UInt__Port.py,sha256=gcqi3UaWaFNSktqUTrfdgRKVI5JKWnqxcpi5FlX75J0,496
 osbot_utils/type_safe/primitives/safe_uint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py,sha256=TYb1nXbVqn4bGoagGqr4U__LofpjDllKxiVJCL705PI,3159
-osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py,sha256=VYlTzDXnreb5s6Ue5AIq-ehxg3jHppOVES0CppjhCsg,2607
-osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py,sha256=j12fc8cbd9-s_a13ysaz723rNEW4Dt6hObCd0S-AjIg,1432
-osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py,sha256=Kx7C4YfHybRbMmVMcmV6yFLi4T48pb592vEZfjjyLxo,1710
+osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py,sha256=IM_5I_cMw6PhJk2bIRZ6siRAh5GR3QwuHCqzuELPzFs,3371
+osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py,sha256=os5dOU7iKnjKoWt00SLj0Wy_X1RL2iGEErsYvg04tto,2719
+osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py,sha256=AqaimwY8Ba-GRI9xsCCZwLmAjMHK3HLV_tJiKXEp7Sc,2575
+osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py,sha256=MEUHVwPDVqPmnZsvxwAhQAQY9JwFsMe2R42z4tWKRN4,3445
 osbot_utils/type_safe/type_safe_core/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/type_safe.py,sha256=wOTMvZBl5hWMz-HuIRZpPBGN0oSbXWd9wH5xxZkfLlA,1796
@@ -434,9 +434,9 @@ osbot_utils/type_safe/type_safe_core/shared/__init__.py,sha256=47DEQpj8HBSa-_TIm
 osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Class_Kwargs.py,sha256=BbMPfCv5-RUZzh-TbyLBvykXZkdkR91jCGJoZ4R697g,8237
 osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Default_Kwargs.py,sha256=tzKXDUc0HVP5QvCWsmcPuuZodNvQZ9FeMDNI2x00Ngw,1943
 osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Default_Value.py,sha256=mRu0yV3w7Ch1H8SOfXMRqMBp3ooY95yR_oni7JafJBc,4603
-osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py,sha256=GTZnGC7DvEBA_LxgLw_KZZ1iVUV0EwyIgcZzoh14Bro,15453
+osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__From_Json.py,sha256=caRTpPbzvBbV18oGHf6MDiazxGfg4tvf4Ik9sc_ikIo,15747
 osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Init.py,sha256=lZpQCCTNt6JcqyWwDoj-9Zgrq10vHXIUBh9lx37vRkE,4990
-osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py,sha256=uIWa5j7NfYcPDt-QGXErxI29HfM26mXAB-ScHC6ruCU,8507
+osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py,sha256=ywUYo97jcZkHZ7BJ7GTTuici2obz-Nwch4TcM6ilDcY,9237
 osbot_utils/type_safe/type_safe_core/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/validators/Type_Safe__Validator.py,sha256=cJIPSBarjV716SZUOLvz7Mthjk-aUYKUQtRDtKUBmN4,779
 osbot_utils/type_safe/validators/Validator__Max.py,sha256=pCvYF5Jb_cBgn1ArGhf6FNUB-NGCXPq3D36oYDCyAzg,1275
@@ -458,7 +458,7 @@ osbot_utils/utils/Json.py,sha256=TvfDoXwOkWzWH-9KMnme5C7iFsMZOleAeue92qmkH6g,883
 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=ZgAwAI8DM8MhFe37WAr2Di5f9-ig3hgayMEinLCF5tc,13571
+osbot_utils/utils/Objects.py,sha256=fLwnB0bv0vqGBE7uGYUxB4IUNEXjn-rjakYz8mp3VVY,14198
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=M9Oi62LxfnRSlCN8GhaiwiBINvcSdGy39FCWjyDD-Xg,12792
@@ -470,8 +470,8 @@ osbot_utils/utils/Toml.py,sha256=grjWkVPIMVkawJ499FVIJKxQp8FJ2wcsd0Z3YIR4drM,114
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=mG42lgTY0tnm14T3P1-DSAIZKkTiYoO3odZ1aOUdc1I,14394
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=Fzq3NVCIMMQXS5Ax5-ZrDEOOQhtNlHqqT--cg6GdXic,8
-osbot_utils-2.85.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.85.0.dist-info/METADATA,sha256=bQaAW7ALWwWNyVCPZRbHVdPZJjch-N7pvoxbl5nEqTI,7918
-osbot_utils-2.85.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.85.0.dist-info/RECORD,,
+osbot_utils/version,sha256=6Cn7UOgy_SJPSb16yrGhCgZKuq2nwG2aj2B0loLVsZc,8
+osbot_utils-2.86.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.86.0.dist-info/METADATA,sha256=hVm2edAsrGB02PyLzWfO5xAOPsvFMntpGOGLCFV4AT4,7918
+osbot_utils-2.86.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.86.0.dist-info/RECORD,,