osbot-utils 2.62.0__py3-none-any.whl → 2.64.0__py3-none-any.whl

osbot_utils/decorators/methods/cache_on_self.py

@@ -1,80 +1,51 @@
-from typing                 import Any, Callable, TypeVar
+import inspect
+from functools                                         import wraps
+from typing import Any, Callable, TypeVar, Dict
+from weakref import WeakKeyDictionary
 
-CACHE_ON_SELF_KEY_PREFIX = '__cache_on_self__'
-CACHE_ON_SELF_TYPES      = [int, float, bytearray, bytes, bool,
-                            complex, str]
+from osbot_utils.helpers.cache_on_self.Cache_On_Self   import Cache_On_Self
 
-# not supported for now (need to understand side effect, )
-# - set, dict, range,, tuple, list      : cloud have inner objects
-# - memoryview                          : returns unique memory location value
 
+T = TypeVar('T', bound=Callable[..., Any])
 
+# Global registry of cache managers per instance per method
+# Structure: {instance: {method_name: Cache_On_Self}}
+_cache_managers_registry: WeakKeyDictionary[Any, Dict[str, Cache_On_Self]] = WeakKeyDictionary()
 
 
-T = TypeVar('T', bound=Callable[..., Any])      # so that we have type hinting when using this class
 
-def cache_on_self(function: T) -> T:            # Use this for cases where we want the cache to be tied to the Class instance (i.e. not global for all executions)
-    import inspect
-    from functools import wraps
+def cache_on_self(function: T) -> T:
+    """
+    Decorator to cache method results on the instance.
+
+    Use this for cases where we want the cache to be tied to the
+    Class instance (i.e. not global for all executions)
+    """
+    function_name = function.__name__
 
     @wraps(function)
     def wrapper(*args, **kwargs):
+        # Extract self from args
+        if not args:
+            raise ValueError("cache_on_self could not find self - no arguments provided")
 
+        self = args[0]
 
-        if len(args) == 0 or inspect.isclass(type(args[0])) is False:
-            raise Exception("In Method_Wrappers.cache_on_self could not find self")
+        # Get or create cache manager for this instance/method combination
+        if self not in _cache_managers_registry:
+            _cache_managers_registry[self] = {}
 
-        reload_cache = False                                                # default is not to reload cache
-        if 'reload_cache' in kwargs:                                        # if the reload parameter is set to True
-            if kwargs['reload_cache'] is True:                              # only if the reload is explicitly set to True
-                reload_cache = True                                         # set reload value to True
-            del kwargs['reload_cache']                                      # remove the reload parameter from the kwargs
+        if function_name not in _cache_managers_registry[self]:
+            # Create new cache manager for this instance/method
+            _cache_managers_registry[self][function_name] = Cache_On_Self(function=function)
 
-        self     = args[0]                                                  # get self
-        cache_id = cache_on_self__get_cache_in_key(function, args, kwargs)  # get cache_id value
+        cache_manager = _cache_managers_registry[self][function_name]
 
-        if reload_cache is True or hasattr(self, cache_id) is False:        # check if return_value has been set or if reload is True
-            return_value = function(*args, **kwargs)                        # invoke function and capture the return value
-            setattr(self, cache_id,return_value)                            # set the return value in the cache
-        return getattr(self, cache_id)                                      # return the return value
-    return wrapper
+        # Handle special __return__ parameter
+        if kwargs.get('__return__') == 'cache_on_self':
+            return cache_manager
 
-def cache_on_self__args_to_str(args):
-    args_values_as_str = ''
-    if args:
-        for arg in args:
-            if type(arg) in CACHE_ON_SELF_TYPES:
-                args_values_as_str += str(arg)
-    return args_values_as_str
-
-def cache_on_self__kwargs_to_str(kwargs):
-    kwargs_values_as_str = ''
-    if kwargs:
-        for key,value in kwargs.items():
-            if type(value) in CACHE_ON_SELF_TYPES:
-                kwargs_values_as_str += f'{key}:{value}|'
-    return kwargs_values_as_str
-
-def cache_on_self__get_cache_in_key(function, args=None, kwargs=None):
-    from osbot_utils.utils.Misc import str_md5
-
-    key_name   = function.__name__
-    args_md5   = ''
-    kwargs_md5 = ''
-    args_values_as_str   = cache_on_self__args_to_str(args)
-    kwargs_values_as_str = cache_on_self__kwargs_to_str(kwargs)
-    if args_values_as_str:
-        args_md5 = str_md5(args_values_as_str)
-    if kwargs_values_as_str:
-        kwargs_md5 = str_md5(kwargs_values_as_str)
-    return f'{CACHE_ON_SELF_KEY_PREFIX}_{key_name}_{args_md5}_{kwargs_md5}'
-
-    # class_name = self_obj.__class__.__name__
-    #
-    # function_name = function_obj.__name__
-    # if params:
-    #     params_as_string = '_'.join(str(x) for x in params).replace('/',' ')
-    #     params_md5       = str_md5(params_as_string)
-    #     return f'{class_name}_{function_name}_{params_md5}.gz'
-    # else:
-    #     return f'{class_name}_{function_name}.gz'
+        # Normal call
+        return cache_manager.handle_call(args, kwargs)
+
+    return wrapper

osbot_utils/helpers/Obj_Id.py

@@ -1,4 +1,5 @@
 import random
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
 _hex_table = [f"{i:02x}" for i in range(256)]
 
@@ -14,7 +15,7 @@ def is_obj_id(value: str):
 def new_obj_id():
     return hex(random.getrandbits(32))[2:].zfill(8)  # slice off '0x' and pad
 
-class Obj_Id(str):
+class Obj_Id(Type_Safe__Primitive,str):
     def __new__(cls, value: str=None):
         if value:
             if is_obj_id(value):

osbot_utils/helpers/Safe_Id.py

@@ -1,6 +1,6 @@
 from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
-from osbot_utils.utils.Misc import random_id_short
-from osbot_utils.utils.Str  import safe_id
+from osbot_utils.utils.Misc                     import random_id_short
+from osbot_utils.utils.Str                      import safe_id
 
 SAFE_ID__MAX_LENGTH = 512
 

osbot_utils/helpers/cache_on_self/Cache_Controller.py

@@ -0,0 +1,28 @@
+import inspect
+from typing import Any, Dict
+
+
+class Cache_Controller:                                                             # Controls cache behavior and reload logic
+
+    def extract_clean_kwargs(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:      # Remove special parameters from kwargs
+        return {k: v for k, v in kwargs.items()
+                if k not in ['reload_cache', '__return__']}
+
+    def should_reload(self, kwargs         : Dict[str, Any] ,
+                            reload_next_flag: bool          ) -> bool:             # Determine if cache should be reloaded
+        if reload_next_flag:
+            return True
+        return kwargs.get('reload_cache', False) is True
+
+    def should_return_cache_manager(self, kwargs: Dict[str, Any]) -> bool:         # Check if should return cache manager
+        return kwargs.get('__return__') == 'cache_on_self'
+
+    def extract_self_from_args(self, args: tuple) -> Any:                          # Validate and extract self from args
+        if len(args) == 0:
+            raise ValueError("cache_on_self could not find self - no arguments provided")
+
+        potential_self = args[0]
+        if not inspect.isclass(type(potential_self)):
+            raise ValueError("cache_on_self could not find self - first argument is not an instance")
+
+        return potential_self

osbot_utils/helpers/cache_on_self/Cache_Key_Generator.py

@@ -0,0 +1,113 @@
+import json
+from typing import Callable, Dict, List, Tuple, Any, Set, FrozenSet
+from osbot_utils.utils.Misc import str_md5
+
+
+CACHE_ON_SELF_TYPES      = [int, float, bytearray, bytes, bool, complex, str]
+CACHE_ON_SELF_KEY_PREFIX = '__cache_on_self__'
+
+
+class Cache_Key_Generator:                                                          # Handles all cache key generation logic
+
+    def __init__(self, supported_types: List[type] = None):
+        self.supported_types = supported_types or CACHE_ON_SELF_TYPES
+
+    def generate_key(self, function : Callable          ,
+                           args     : Tuple   [Any, ...],
+                           kwargs   : Dict    [str, Any]
+                      ) -> str:                             # Generate cache key from function name and arguments
+        key_name    = function.__name__
+        args_hash   = self.get_args_hash(args)
+        kwargs_hash = self.get_kwargs_hash(kwargs)
+        return f'{CACHE_ON_SELF_KEY_PREFIX}_{key_name}_{args_hash}_{kwargs_hash}'
+
+    def get_args_hash(self, args: Tuple[Any, ...]) -> str:                         # Get hash for args or empty string if no hashable args
+        args_str = self.args_to_str(args)
+        if args_str:
+            return self.compute_hash(args_str)
+        return ''
+
+    def get_kwargs_hash(self, kwargs: Dict[str, Any]) -> str:                      # Get hash for kwargs or empty string if no hashable kwargs
+        kwargs_str = self.kwargs_to_str(kwargs)
+        if kwargs_str:
+            return self.compute_hash(kwargs_str)
+        return ''
+
+    def args_to_str(self, args: Tuple[Any, ...]) -> str:                           # Convert supported args to string representation
+        if not args:
+            return ''
+
+        parts = []
+        for i, arg in enumerate(args):
+            arg_str = self.value_to_cache_str(arg)
+            if arg_str:
+                # Include index to avoid collisions like (1, 23) vs (12, 3)
+                parts.append(f"[{i}]:{arg_str}")
+        return '|'.join(parts)
+
+    def kwargs_to_str(self, kwargs: Dict[str, Any]) -> str:                        # Convert supported kwargs to string representation
+        if not kwargs:
+            return ''
+
+        parts = []
+        for key, value in sorted(kwargs.items()):  # Sort for consistent ordering
+            value_str = self.value_to_cache_str(value)
+            if value_str:
+                parts.append(f'{key}:{value_str}')
+        return '|'.join(parts)
+
+    def value_to_cache_str(self, value: Any) -> str:                              # Convert a value to a cacheable string representation
+        """Convert any value to a string suitable for cache key generation.
+
+        Returns a type-prefixed string for all supported types.
+        Returns empty string ONLY for unsupported types.
+        """
+        if value is None:
+            return '<none>'
+
+        # Handle primitive types with type prefix to avoid any collision
+        value_type = type(value)
+        if value_type in self.supported_types:
+            type_name = value_type.__name__
+            return f"<{type_name}>:{value}"
+
+        # Handle mutable types by converting to a stable string representation
+        try:
+            if isinstance(value, dict):
+                # Sort dict by keys for consistent ordering
+                sorted_items = sorted(value.items())
+                return f"<dict>:{json.dumps(sorted_items, sort_keys=True, separators=(',', ':'))}"
+
+            elif isinstance(value, list):
+                return f"<list>:{json.dumps(value, separators=(',', ':'))}"
+
+            elif isinstance(value, tuple):
+                return f"<tuple>:{json.dumps(value, separators=(',', ':'))}"
+
+            elif isinstance(value, set):
+                # Convert to sorted list for consistent ordering
+                return f"<set>:{json.dumps(sorted(list(value)), separators=(',', ':'))}"
+
+            elif isinstance(value, frozenset):
+                return f"<frozenset>:{json.dumps(sorted(list(value)), separators=(',', ':'))}"
+
+            else:
+                # For other types, try to use repr if it's likely to be stable
+                # This is a fallback - specific types should be handled above
+                if hasattr(value, '__dict__'):
+                    # For objects, we could hash their dict representation
+                    # But this is risky, so we'll skip for now
+                    return ''
+                else:
+                    # For other immutable types, try repr
+                    try:
+                        return f"other:{repr(value)}"
+                    except:
+                        return ''
+
+        except (TypeError, ValueError, RecursionError):
+            # If we can't serialize the value, skip it
+            return ''
+
+    def compute_hash(self, value: str) -> str:                                     # Compute hash of string value
+        return str_md5(value)

osbot_utils/helpers/cache_on_self/Cache_Metrics.py

@@ -0,0 +1,31 @@
+class Cache_Metrics:                                                                # Track cache performance metrics
+
+    def __init__(self):
+        self.hits                    = 0
+        self.misses                  = 0
+        self.reloads                 = 0
+        self.key_generation_time     = 0.0
+        self.cache_lookup_time       = 0.0
+        self.function_execution_time = 0.0
+
+    @property
+    def hit_rate(self) -> float:                                                    # Calculate cache hit rate
+        total = self.hits + self.misses
+        return self.hits / total if total > 0 else 0.0
+
+    def record_hit(self) -> None:                                                   # Record cache hit
+        self.hits += 1
+
+    def record_miss(self) -> None:                                                  # Record cache miss
+        self.misses += 1
+
+    def record_reload(self) -> None:                                                # Record cache reload
+        self.reloads += 1
+
+    def reset(self) -> None:                                                        # Reset all metrics
+        self.hits                    = 0
+        self.misses                  = 0
+        self.reloads                 = 0
+        self.key_generation_time     = 0.0
+        self.cache_lookup_time       = 0.0
+        self.function_execution_time = 0.0

osbot_utils/helpers/cache_on_self/Cache_On_Self.py

@@ -0,0 +1,124 @@
+from typing                                                import Any, Callable, Dict, List
+from osbot_utils.type_safe.Type_Safe                       import Type_Safe
+from osbot_utils.helpers.cache_on_self.Cache_Controller    import Cache_Controller
+from osbot_utils.helpers.cache_on_self.Cache_Key_Generator import Cache_Key_Generator, CACHE_ON_SELF_KEY_PREFIX
+from osbot_utils.helpers.cache_on_self.Cache_Metrics       import Cache_Metrics
+from osbot_utils.helpers.cache_on_self.Cache_Storage       import Cache_Storage
+
+
+class Cache_On_Self(Type_Safe):
+    cache_storage       : Cache_Storage                                             # Storage handler instance
+    controller          : Cache_Controller                                          # Controller instance
+    key_generator       : Cache_Key_Generator                                       # Key generator instance
+    metrics             : Cache_Metrics                                             # Metrics tracking
+    function            : Callable                                                  # The wrapped function
+    function_name       : str                                                       # Cached function name
+    no_args_key         : str                                                       # Pre-computed key for no args
+    target_self         : Any                        = None                         # The instance being cached on
+    current_cache_key   : str                        = ''                           # Current cache key
+    current_cache_value : Any                        = None                         # Current cached value
+    reload_next         : bool                       = False                        # Force reload on next call
+    disabled            : bool                       = False                         # cache disable status
+
+    def __init__(self, function       : Callable                   = None ,
+                       supported_types: List[type]                 = None ):
+        super().__init__()
+        self.function       = function
+        self.function_name  = function.__name__ if function else ''
+        self.no_args_key    = f'{CACHE_ON_SELF_KEY_PREFIX}_{self.function_name}__' # Pre-compute for performance
+        self.cache_storage  = Cache_Storage()
+        self.controller     = Cache_Controller()
+        self.key_generator  = Cache_Key_Generator(supported_types)
+        self.metrics        = Cache_Metrics()
+
+    def handle_call(self, args: tuple, kwargs: dict) -> Any:                        # Main entry point for cached calls
+        # Check if caching is disabled
+        if self.disabled:
+            return self.execute(args, kwargs)
+
+        if not kwargs and len(args) == 1:                                           # Fast path for common case: no kwargs, single arg (self)
+            target_self = args[0]
+            cache_key   = self.no_args_key
+
+            if self.cache_storage.has_cached_value(target_self, cache_key):         # Use cache_storage
+                self.metrics.hits += 1                                              # Increment cache Hit
+                return self.cache_storage.get_cached_value(target_self, cache_key)  # Use cache_storage
+
+            self.metrics.misses += 1                                                # Increment cache miss - execute and store (Direct increment)
+            result = self.function(*args)
+            self.cache_storage.set_cached_value(target_self, cache_key, result)    # Use cache_storage instead of setattr
+            return result
+
+        return self.handle_call_full(args, kwargs)
+
+    def handle_call_full(self, args  : tuple,
+                               kwargs: dict
+                          ) -> Any:                                                 # Full logic for complex cases
+        # Check if caching is disabled
+        if self.disabled:
+            clean_kwargs = self.controller.extract_clean_kwargs(kwargs)
+            return self.execute(args, clean_kwargs)
+
+        # Extract values - don't store as instance variables to avoid recursion issues
+        target_self   = self.controller.extract_self_from_args(args)
+        clean_kwargs  = self.controller.extract_clean_kwargs(kwargs)
+        should_reload = self.controller.should_reload(kwargs, self.reload_next)
+        cache_key     = self.key_generator.generate_key(self.function, args, clean_kwargs)
+
+        if should_reload:
+            self.reload_next = False                                                # Reset reload flag
+
+        cached_exists = self.cache_storage.has_cached_value(target_self, cache_key)
+
+        if should_reload or not cached_exists:
+            # Execute and cache, passing the cache key directly
+            result = self.execute_and_cache(args, clean_kwargs, target_self, cache_key, should_reload)
+        else:
+            self.metrics.record_hit()
+            result = self.cache_storage.get_cached_value(target_self, cache_key)
+
+        # Update instance state only for external inspection
+        self.target_self = target_self
+        self.current_cache_key = cache_key
+        self.current_cache_value = result
+
+        return result
+
+    def execute(self, args   : tuple,
+                      kwargs : dict ,
+                 ) -> Any:                                # Execute function
+        return self.function(*args, **kwargs)
+
+    def execute_and_cache(self, args         : tuple,
+                                clean_kwargs : dict,
+                                target_self  : Any,
+                                cache_key    : str,
+                                should_reload: bool) -> Any:                      # Execute function and store result
+        if should_reload:
+            self.metrics.record_reload()
+        else:
+            self.metrics.record_miss()
+
+        result = self.execute(args=args, kwargs=clean_kwargs)
+        self.cache_storage.set_cached_value(target_self, cache_key, result)
+        return result
+
+    def clear(self) -> None:                                                        # Clear current cache entry
+        if self.target_self and self.current_cache_key:
+            self.cache_storage.clear_key(self.target_self, self.current_cache_key)
+
+    def clear_all(self) -> None:                                                    # Clear all cache for current instance
+        if self.target_self:
+            self.cache_storage.clear_all(self.target_self)
+
+    def get_all_keys(self) -> List[str]:                                           # Get all cache keys for current instance
+        if self.target_self:
+            return self.cache_storage.get_all_cache_keys(self.target_self)
+        return []
+
+    def stats(self) -> Dict[str, Any]:                                             # Get cache statistics
+        return { 'hits'      : self.metrics.hits      ,
+                 'misses'    : self.metrics.misses    ,
+                 'reloads'   : self.metrics.reloads   ,
+                 'hit_rate'  : self.metrics.hit_rate  ,
+                 'cache_key' : self.current_cache_key }

osbot_utils/helpers/cache_on_self/Cache_Storage.py

@@ -0,0 +1,33 @@
+from weakref import WeakKeyDictionary
+from typing import Any, Dict, List
+
+class Cache_Storage:    # Handles all cache storage without polluting instance attributes
+
+    def __init__(self):
+        self.cache_data: WeakKeyDictionary = WeakKeyDictionary()  # Use WeakKeyDictionary so cache is automatically cleaned up when instances are garbage collected , instance -> {cache_key: value}
+
+    def has_cached_value(self, instance: Any, cache_key: str) -> bool:
+        if instance in self.cache_data:
+            return cache_key in self.cache_data[instance]
+        return False
+
+    def get_cached_value(self, instance: Any, cache_key: str) -> Any:
+        return self.cache_data[instance][cache_key]
+
+    def set_cached_value(self, instance: Any, cache_key: str, value: Any) -> None:
+        if instance not in self.cache_data:
+            self.cache_data[instance] = {}
+        self.cache_data[instance][cache_key] = value
+
+    def get_all_cache_keys(self, instance: Any) -> List[str]:
+        if instance in self.cache_data:
+            return list(self.cache_data[instance].keys())
+        return []
+
+    def clear_key(self, instance: Any, cache_key: str) -> None:
+        if instance in self.cache_data:
+            self.cache_data[instance].pop(cache_key, None)
+
+    def clear_all(self, instance: Any) -> None:
+        if instance in self.cache_data:
+            del self.cache_data[instance]

osbot_utils/helpers/cache_on_self/__init__.py

@@ -0,0 +1,145 @@
+# note 1: this __init__.py file needs to be here (vs inside the /utils/ast/nodes folder)
+#         so that the methods registration happens as soon as somebody uses a method from the /utils/ast folder/package
+# note 2: this is needed due to the circular dependencyes between the Ast_Node and the
+#         clases that use it as a base class
+
+import ast
+from osbot_utils.helpers.Type_Registry                import type_registry
+from osbot_utils.helpers.ast.nodes.Ast_Add            import Ast_Add
+from osbot_utils.helpers.ast.nodes.Ast_Alias          import Ast_Alias
+from osbot_utils.helpers.ast.nodes.Ast_And            import Ast_And
+from osbot_utils.helpers.ast.nodes.Ast_Argument       import Ast_Argument
+from osbot_utils.helpers.ast.nodes.Ast_Arguments      import Ast_Arguments
+from osbot_utils.helpers.ast.nodes.Ast_Assert         import Ast_Assert
+from osbot_utils.helpers.ast.nodes.Ast_Assign         import Ast_Assign
+from osbot_utils.helpers.ast.nodes.Ast_Attribute      import Ast_Attribute
+from osbot_utils.helpers.ast.nodes.Ast_Aug_Assign     import Ast_Aug_Assign
+from osbot_utils.helpers.ast.nodes.Ast_Bin_Op         import Ast_Bin_Op
+from osbot_utils.helpers.ast.nodes.Ast_Bool_Op        import Ast_Bool_Op
+from osbot_utils.helpers.ast.nodes.Ast_Break          import Ast_Break
+from osbot_utils.helpers.ast.nodes.Ast_Call           import Ast_Call
+from osbot_utils.helpers.ast.nodes.Ast_Class_Def      import Ast_Class_Def
+from osbot_utils.helpers.ast.nodes.Ast_Compare        import Ast_Compare
+from osbot_utils.helpers.ast.nodes.Ast_Comprehension  import Ast_Comprehension
+from osbot_utils.helpers.ast.nodes.Ast_Constant       import Ast_Constant
+from osbot_utils.helpers.ast.nodes.Ast_Continue       import Ast_Continue
+from osbot_utils.helpers.ast.nodes.Ast_Dict           import Ast_Dict
+from osbot_utils.helpers.ast.nodes.Ast_Eq             import Ast_Eq
+from osbot_utils.helpers.ast.nodes.Ast_Except_Handler import Ast_Except_Handler
+from osbot_utils.helpers.ast.nodes.Ast_Expr           import Ast_Expr
+from osbot_utils.helpers.ast.nodes.Ast_For            import Ast_For
+from osbot_utils.helpers.ast.nodes.Ast_Function_Def   import Ast_Function_Def
+from osbot_utils.helpers.ast.nodes.Ast_Generator_Exp  import Ast_Generator_Exp
+from osbot_utils.helpers.ast.nodes.Ast_Gt             import Ast_Gt
+from osbot_utils.helpers.ast.nodes.Ast_GtE            import Ast_GtE
+from osbot_utils.helpers.ast.nodes.Ast_If             import Ast_If
+from osbot_utils.helpers.ast.nodes.Ast_If_Exp         import Ast_If_Exp
+from osbot_utils.helpers.ast.nodes.Ast_Import         import Ast_Import
+from osbot_utils.helpers.ast.nodes.Ast_Import_From    import Ast_Import_From
+from osbot_utils.helpers.ast.nodes.Ast_In             import Ast_In
+from osbot_utils.helpers.ast.nodes.Ast_Is             import Ast_Is
+from osbot_utils.helpers.ast.nodes.Ast_Is_Not         import Ast_Is_Not
+from osbot_utils.helpers.ast.nodes.Ast_Keyword        import Ast_Keyword
+from osbot_utils.helpers.ast.nodes.Ast_Lambda         import Ast_Lambda
+from osbot_utils.helpers.ast.nodes.Ast_List           import Ast_List
+from osbot_utils.helpers.ast.nodes.Ast_List_Comp      import Ast_List_Comp
+from osbot_utils.helpers.ast.nodes.Ast_Load           import Ast_Load
+from osbot_utils.helpers.ast.nodes.Ast_Lt             import Ast_Lt
+from osbot_utils.helpers.ast.nodes.Ast_LtE            import Ast_LtE
+from osbot_utils.helpers.ast.nodes.Ast_Mod            import Ast_Mod
+from osbot_utils.helpers.ast.nodes.Ast_Module         import Ast_Module
+from osbot_utils.helpers.ast.nodes.Ast_Mult           import Ast_Mult
+from osbot_utils.helpers.ast.nodes.Ast_Name           import Ast_Name
+from osbot_utils.helpers.ast.nodes.Ast_Not            import Ast_Not
+from osbot_utils.helpers.ast.nodes.Ast_Not_Eq         import Ast_Not_Eq
+from osbot_utils.helpers.ast.nodes.Ast_Not_In         import Ast_Not_In
+from osbot_utils.helpers.ast.nodes.Ast_Or             import Ast_Or
+from osbot_utils.helpers.ast.nodes.Ast_Pass           import Ast_Pass
+from osbot_utils.helpers.ast.nodes.Ast_Pow            import Ast_Pow
+from osbot_utils.helpers.ast.nodes.Ast_Raise          import Ast_Raise
+from osbot_utils.helpers.ast.nodes.Ast_Return         import Ast_Return
+from osbot_utils.helpers.ast.nodes.Ast_Set            import Ast_Set
+from osbot_utils.helpers.ast.nodes.Ast_Slice          import Ast_Slice
+from osbot_utils.helpers.ast.nodes.Ast_Starred        import Ast_Starred
+from osbot_utils.helpers.ast.nodes.Ast_Store          import Ast_Store
+from osbot_utils.helpers.ast.nodes.Ast_Sub            import Ast_Sub
+from osbot_utils.helpers.ast.nodes.Ast_Subscript      import Ast_Subscript
+from osbot_utils.helpers.ast.nodes.Ast_Try            import Ast_Try
+from osbot_utils.helpers.ast.nodes.Ast_Tuple          import Ast_Tuple
+from osbot_utils.helpers.ast.nodes.Ast_Unary_Op       import Ast_Unary_Op
+from osbot_utils.helpers.ast.nodes.Ast_While          import Ast_While
+from osbot_utils.helpers.ast.nodes.Ast_With           import Ast_With
+from osbot_utils.helpers.ast.nodes.Ast_With_Item      import Ast_With_Item
+from osbot_utils.helpers.ast.nodes.Ast_Yield          import Ast_Yield
+
+ast_types = {
+    ast.Add           : Ast_Add           ,
+    ast.alias         : Ast_Alias         ,
+    ast.And           : Ast_And           ,
+    ast.Assert        : Ast_Assert        ,
+    ast.Assign        : Ast_Assign        ,
+    ast.Attribute     : Ast_Attribute     ,
+    ast.arg           : Ast_Argument      ,
+    ast.arguments     : Ast_Arguments     ,
+    ast.AugAssign     : Ast_Aug_Assign    ,
+    ast.BinOp         : Ast_Bin_Op        ,
+    ast.BoolOp        : Ast_Bool_Op       ,
+    ast.Break         : Ast_Break         ,
+    ast.Call          : Ast_Call          ,
+    ast.ClassDef      : Ast_Class_Def     ,
+    ast.Compare       : Ast_Compare       ,
+    ast.Constant      : Ast_Constant      ,
+    ast.Continue      : Ast_Continue      ,
+    ast.comprehension : Ast_Comprehension ,
+    ast.Dict          : Ast_Dict          ,
+    ast.ExceptHandler : Ast_Except_Handler,
+    ast.Expr          : Ast_Expr          ,
+    ast.Eq            : Ast_Eq            ,
+    ast.Gt            : Ast_Gt            ,
+    ast.GtE           : Ast_GtE           ,
+    ast.Import        : Ast_Import        ,
+    ast.ImportFrom    : Ast_Import_From   ,
+    ast.In            : Ast_In            ,
+    ast.For           : Ast_For           ,
+    ast.FunctionDef   : Ast_Function_Def  ,
+    ast.GeneratorExp  : Ast_Generator_Exp ,
+    ast.If            : Ast_If            ,
+    ast.IfExp         : Ast_If_Exp        ,
+    ast.Is            : Ast_Is            ,
+    ast.IsNot         : Ast_Is_Not        ,
+    ast.keyword       : Ast_Keyword       ,
+    ast.Lambda        : Ast_Lambda        ,
+    ast.List          : Ast_List          ,
+    ast.ListComp      : Ast_List_Comp     ,
+    ast.Lt            : Ast_Lt            ,
+    ast.LtE           : Ast_LtE           ,
+    ast.Load          : Ast_Load          ,
+    ast.Mod           : Ast_Mod           ,
+    ast.Module        : Ast_Module        ,
+    ast.Mult          : Ast_Mult          ,
+    ast.Name          : Ast_Name          ,
+    ast.Not           : Ast_Not           ,
+    ast.NotEq         : Ast_Not_Eq        ,
+    ast.NotIn         : Ast_Not_In        ,
+    ast.Or            : Ast_Or            ,
+    ast.Pass          : Ast_Pass          ,
+    ast.Pow           : Ast_Pow           ,
+    ast.Raise         : Ast_Raise         ,
+    ast.Return        : Ast_Return        ,
+    ast.Slice         : Ast_Slice         ,
+    ast.Starred       : Ast_Starred       ,
+    ast.Store         : Ast_Store         ,
+    ast.Set           : Ast_Set           ,
+    ast.Sub           : Ast_Sub           ,
+    ast.Subscript     : Ast_Subscript     ,
+    ast.Try           : Ast_Try           ,
+    ast.Tuple         : Ast_Tuple         ,
+    ast.UnaryOp       : Ast_Unary_Op      ,
+    ast.While         : Ast_While         ,
+    ast.With          : Ast_With          ,
+    ast.withitem      : Ast_With_Item     ,
+    ast.Yield         : Ast_Yield         ,
+}
+
+for key, value in ast_types.items():
+    type_registry.register(key, value)

osbot_utils/type_safe/Type_Safe__List.py

@@ -1,6 +1,8 @@
-from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base, type_str
+from typing                                 import Type
+from osbot_utils.type_safe.Type_Safe__Base  import Type_Safe__Base, type_str
 
 class Type_Safe__List(Type_Safe__Base, list):
+    expected_type : Type
 
     def __init__(self, expected_type, *args):
         super().__init__(*args)
@@ -21,7 +23,7 @@ class Type_Safe__List(Type_Safe__Base, list):
             try:
                 self.is_instance_of_type(item, self.expected_type)
             except TypeError as e:
-               raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}")
+               raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}") from None
         super().append(item)
 
 

osbot_utils/type_safe/Type_Safe__Method.py

@@ -185,5 +185,5 @@ class Type_Safe__Method:
             base_type = expected_type
 
         if not isinstance(param_value, base_type):
-            raise ValueError(f"Parameter '{param_name}' expected type {expected_type}, but got {type(param_value)}")
+            raise ValueError(f"Parameter '{param_name}' expected type {expected_type}, but got {type(param_value)}") from None
         return True

osbot_utils/type_safe/Type_Safe__Primitive.py

@@ -9,6 +9,19 @@ class Type_Safe__Primitive:
                 cls.__primitive_base__ = base
                 break
 
+    def __add__(self, other):
+        """Override addition/concatenation to maintain type safety"""
+        if self.__primitive_base__ is str:                                      # For string concatenation
+            result = super().__add__(other)                                     # Perform the operation
+            return type(self)(result)                                           # Return instance of the safe type
+        else:                                                                   # For numeric types (int, float)
+            result = super().__add__(other)
+            try:
+                return type(self)(result)                                       # Try to create safe type
+            except (ValueError, TypeError):
+                return result                                                   # Fall back to primitive if constraints violated
+
+
     def __eq__(self, other):
         if type(self) is type(other):                                           # Same type → compare values
             return super().__eq__(other)
@@ -22,7 +35,30 @@ class Type_Safe__Primitive:
     def __hash__(self):                                                     # Include type in hash to maintain hash/eq contract , This works for str, int, float subclasses
         return hash((type(self).__name__, super().__hash__()))
 
-    def __repr__(self):                                                     # Enhanced repr to show type information in assertions
-        value_repr = super().__repr__()
-        return f"{type(self).__name__}({value_repr})"
+    def __radd__(self, other):
+        """Reverse addition/concatenation for when safe type is on the right"""
+        if self.__primitive_base__ is str:
+            result = other + str(self)                                         # Perform string concatenation
+            return type(self)(result)                                          # Return instance of the safe type
+        else:
+            result = other + self.__primitive_base__(self)
+            try:
+                return type(self)(result)
+            except (ValueError, TypeError):
+                return result
+
+    def __str__(self):                                              # Return the primitive string representation"""
+        if self.__primitive_base__ is float:                        # Format the value using the primitive type's string formatting
+            return format(float(self), '')
+        elif self.__primitive_base__ is int:
+            return format(int(self), '')
+        elif self.__primitive_base__ is str:
+            return str.__str__(self)
+        return super().__str__()
 
+    def __repr__(self):                                             # Enhanced repr for debugging that shows type information
+        value_str = self.__str__()
+        if self.__primitive_base__ is str:
+            return f"{type(self).__name__}('{value_str}')"
+        else:
+            return f"{type(self).__name__}({value_str})"

osbot_utils/type_safe/shared/Type_Safe__Raise_Exception.py

@@ -5,10 +5,10 @@ class Type_Safe__Raise_Exception:
 
     def type_mismatch_error(self, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
         exception_message = f"Invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
-        raise ValueError(exception_message)
+        raise ValueError(exception_message) from None
 
     def immutable_type_error(self, var_name, var_type):
-        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
-        raise ValueError(exception_message)
+        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}' and the following subclasses (int, float, str)"
+        raise ValueError(exception_message) from None
 
 type_safe_raise_exception = Type_Safe__Raise_Exception()

osbot_utils/type_safe/shared/Type_Safe__Validation.py

@@ -289,7 +289,7 @@ class Type_Safe__Validation:
             if self.obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                        # if var_type is not something like Optional[Union[int, str]]
                 if var_type not in IMMUTABLE_TYPES or type(var_type) not in IMMUTABLE_TYPES:
                     if not isinstance(var_type, EnumMeta):
-                        if not issubclass(var_type, (int,str, float)):
+                        if not (isinstance(var_type, type) and issubclass(var_type, (int,str, float))):
                             type_safe_raise_exception.immutable_type_error(var_name, var_type)
 
     def validate_variable_type(self, var_name, var_type, var_value):                                # Validate type compatibility

osbot_utils/type_safe/steps/Type_Safe__Step__Init.py

@@ -25,7 +25,7 @@ class Type_Safe__Step__Init:
                     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")
+                                 f"Use {__self.__class__.__name__}.__default_kwargs__() see what attributes are available") from None
 
     def convert_value_to_type_safe_objects(self, __self, key, value):
         annotation = type_safe_annotations.obj_attribute_annotation(__self, key)

osbot_utils/version

@@ -1 +1 @@
-v2.62.0
+v2.64.0

{osbot_utils-2.62.0.dist-info → osbot_utils-2.64.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.62.0
+Version: 2.64.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -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-v2.62.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.64.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-2.62.0.dist-info → osbot_utils-2.64.0.dist-info}/RECORD

@@ -16,7 +16,7 @@ osbot_utils/decorators/lists/index_by.py,sha256=Awk3ebtYVywxnb51V-ZGE8pd1fwd8J42
 osbot_utils/decorators/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/decorators/methods/cache.py,sha256=IMmHBeR6qtaOfBNgZUeI1SVLoexQQy6vk1LDW-20_5w,1062
 osbot_utils/decorators/methods/cache_on_function.py,sha256=sDebxWjJnusb_w4R26OTYcmTF6CCeWrpesn-dgzEu8g,2694
-osbot_utils/decorators/methods/cache_on_self.py,sha256=Zf3rhUkoU9ucpkZyN0jZ8i4JTX3cwYwfUpUfExWDyRM,3628
+osbot_utils/decorators/methods/cache_on_self.py,sha256=KCdqQ9y11xKBAuXGK5TV40CVQBNgF-30-aYeTdktCS0,1698
 osbot_utils/decorators/methods/cache_on_tmp.py,sha256=8wLnRAUUkHobu6-B2Q8aAE8jLeIu3b-CQuMtXcnIN9w,3102
 osbot_utils/decorators/methods/capture_exception.py,sha256=r6d1TPibAVLL7B4I0oXtnHQwFFdLBZbDnytYWO6PxS4,1174
 osbot_utils/decorators/methods/capture_status.py,sha256=5xklG0usO3hGTjedhrmIucXtUjPd2pkuvA5jsty0a5E,659
@@ -38,13 +38,13 @@ osbot_utils/helpers/Guid.py,sha256=0Ay3TYYk2nPr-JRVRCMFxbr8OvoQomv5HjT7o5B7cos,8
 osbot_utils/helpers/Hashicorp_Secrets.py,sha256=e2fWWHK6bubpAm1sw5y8X5kh2Hk5d4JyZCnUovZip5A,4232
 osbot_utils/helpers/Local_Cache.py,sha256=67qmeVXUBhfqLUQhjFBE9Pjt5dcjpQYhqCTGQNWgVSU,3232
 osbot_utils/helpers/Local_Caches.py,sha256=LUeNJX07Ccnp1SIhYvhqqQFVF6r_Ez7bWha8ssomuvY,1957
-osbot_utils/helpers/Obj_Id.py,sha256=sdKlSmEUpie0kn9X4pnM0MjUr6sLu4WZLSNqsD8ynBg,926
+osbot_utils/helpers/Obj_Id.py,sha256=T6HF8khO7u1C688Ref_8Li2zxowRc9pIghUkMwb6H1c,1023
 osbot_utils/helpers/Print_Table.py,sha256=LEXbyqGg_6WSraI4cob4bNNSu18ddqvALp1zGK7bPhs,19126
 osbot_utils/helpers/Python_Audit.py,sha256=shpZlluJwqJBAlad6xN01FkgC1TsQ48RLvR5ZjmrKa4,1539
 osbot_utils/helpers/Random_Guid.py,sha256=86xnlevsiitCzFB-VjjBmXXV14pbcKd67YWEDsYTCFk,483
 osbot_utils/helpers/Random_Guid_Short.py,sha256=YP_k5OLuYvXWGU2OEnQHk_OGViBQofTWKm3pUdQaJao,404
 osbot_utils/helpers/Random_Seed.py,sha256=14btja8LDN9cMGWaz4fCNcMRU_eyx49gas-_PQvHgy4,634
-osbot_utils/helpers/Safe_Id.py,sha256=C7IcE8GwyvLbhzc6ImIafmdlCcR6vV7aQU9-oq-kIJE,656
+osbot_utils/helpers/Safe_Id.py,sha256=Mj66QVcEHqUKDFb0cdl7cbMOlQKxfFuRxnupmKo6UG8,696
 osbot_utils/helpers/Str_ASCII.py,sha256=PRqyu449XnKrLn6b9Miii1Hv-GO5OAa1UhhgvlRcC2M,704
 osbot_utils/helpers/Timestamp_Now.py,sha256=OZwSwmYA1pZAnVglpx2lBL5t8Pu_HxzmYdNEJnmTqKI,536
 osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbGuEN3S94,311
@@ -126,6 +126,12 @@ osbot_utils/helpers/ast/nodes/Ast_With.py,sha256=MO3doSFTxQEXUm8t4wDG5hFfWa_ByOM
 osbot_utils/helpers/ast/nodes/Ast_With_Item.py,sha256=ger_t7_sEb2HiHpFwXBRAUJTCgXBfKZyv2uGuHMnQqA,260
 osbot_utils/helpers/ast/nodes/Ast_Yield.py,sha256=7ATJnOHekV9XquMTYYSJ6xqyDvgwFc596myKPpHLddk,197
 osbot_utils/helpers/ast/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/cache_on_self/Cache_Controller.py,sha256=JN-kwLqxTXzrtRxZs9PJUKh4SGVE-bHx10wXw5QuEZE,1342
+osbot_utils/helpers/cache_on_self/Cache_Key_Generator.py,sha256=3L4v7gDi2sLoegL3obwKPKbGzv3Woi19-laHrrDsvGw,4937
+osbot_utils/helpers/cache_on_self/Cache_Metrics.py,sha256=8bGl2kCkJE9z2kLvcXk4WRd10Av2wxiNY6LP6Wg6WyY,1362
+osbot_utils/helpers/cache_on_self/Cache_On_Self.py,sha256=IOQWXG_eJ6HjQQxRhXvU8dk4T7r9dsWxL5YMNOsZRrE,7100
+osbot_utils/helpers/cache_on_self/Cache_Storage.py,sha256=4tl5P1ckzHsQhuSy1V1SO8wp-n-qCKW558xoIBpZo5E,1397
+osbot_utils/helpers/cache_on_self/__init__.py,sha256=Q2hGnJ-3ql63uL7iJzCv3a9m8yrmaAAm6_hlFzSjcgE,8157
 osbot_utils/helpers/cache_requests/Cache__Requests__Actions.py,sha256=PnCJdNltS8GGHSjmUMLF2u7zRT3Ym8M7DIT3n9LkJlw,1225
 osbot_utils/helpers/cache_requests/Cache__Requests__Config.py,sha256=cGjtPB-K_0Wk4bKbS26A3Rg2HAcBhWlMoZE0isBpRdc,932
 osbot_utils/helpers/cache_requests/Cache__Requests__Data.py,sha256=cWVViRSVbS_V7AYxSjR91Wg1UYPi--zbzGmnAZ6t8n0,5501
@@ -367,9 +373,9 @@ osbot_utils/testing/performance/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 osbot_utils/type_safe/Type_Safe.py,sha256=LOWRGOGpnRU2iTRLP47vUoyalK0vjFrWlnaghBIogWg,6267
 osbot_utils/type_safe/Type_Safe__Base.py,sha256=UTMipTL6mXoetAEUCI5hs8RqXp4NDYOvoAiYoFOt5jg,8807
 osbot_utils/type_safe/Type_Safe__Dict.py,sha256=QB200L5eNWT3FnUv8sm5kncj1wXJsJ9uRycNFl9xb6Y,3077
-osbot_utils/type_safe/Type_Safe__List.py,sha256=KyK_DpRM-ACHWPhIaqrNh0cNZhLC9vcsEhcxMi1UF9s,1799
-osbot_utils/type_safe/Type_Safe__Method.py,sha256=PRV4enbwuD81QKP_5UtUA3OAp0m0xSiUhwkCoseZoq4,15687
-osbot_utils/type_safe/Type_Safe__Primitive.py,sha256=RpogRqGJF2qzlsXsgDhyXkez_SjY_IsVIJBn7mmkSiU,1569
+osbot_utils/type_safe/Type_Safe__List.py,sha256=y_lp7Ai0HfQCqC8Bxn0g6_M9MP5lPOXy5Dhkuj2fJvQ,1891
+osbot_utils/type_safe/Type_Safe__Method.py,sha256=lHBCpW5nf2ikybm9oucvq6L67VXNO4qEvzGskJ1hGHs,15697
+osbot_utils/type_safe/Type_Safe__Primitive.py,sha256=CJ4LP2W5i9utSSzuiiJrwqvwdMv1DeQ6dIZICtYfLTY,3635
 osbot_utils/type_safe/Type_Safe__Set.py,sha256=j12fc8cbd9-s_a13ysaz723rNEW4Dt6hObCd0S-AjIg,1432
 osbot_utils/type_safe/Type_Safe__Tuple.py,sha256=Kx7C4YfHybRbMmVMcmV6yFLi4T48pb592vEZfjjyLxo,1710
 osbot_utils/type_safe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -383,15 +389,15 @@ osbot_utils/type_safe/shared/Type_Safe__Convert.py,sha256=q1ds7AqgNhZX1pW0SNq_VN
 osbot_utils/type_safe/shared/Type_Safe__Json_Compressor.py,sha256=TDbot_NNzCPXBQv0l5mksWueJNfxlVFDBGxIH8Jf_XY,5426
 osbot_utils/type_safe/shared/Type_Safe__Json_Compressor__Type_Registry.py,sha256=wYOCg7F1nTrRn8HlnZvrs_8A8WL4gxRYRLnXZpGIiuk,1119
 osbot_utils/type_safe/shared/Type_Safe__Not_Cached.py,sha256=25FAl6SOLxdStco_rm9tgOYLfuKyBWheGdl7vVa56UU,800
-osbot_utils/type_safe/shared/Type_Safe__Raise_Exception.py,sha256=pbru8k8CTQMNUfmFBndiJhg2KkqEYzFvJAPcNZHeHfQ,829
+osbot_utils/type_safe/shared/Type_Safe__Raise_Exception.py,sha256=TMO4uqPLzie79kSqPAP3s6Xa3LtBI_Sql1ou3-3_XBo,896
 osbot_utils/type_safe/shared/Type_Safe__Shared__Variables.py,sha256=SuZGl9LryQX6IpOE0I_lbzClT-h17UNylC__-M8ltTY,129
-osbot_utils/type_safe/shared/Type_Safe__Validation.py,sha256=xkpcj04owSap5DSG9m9FM1bnTje2I_xRFUfsH-R6mrQ,19509
+osbot_utils/type_safe/shared/Type_Safe__Validation.py,sha256=1XvbWJmRfyqBcdOTuYZ5fiItyMF0ttSPFnWjqZTGbYE,19542
 osbot_utils/type_safe/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/steps/Type_Safe__Step__Class_Kwargs.py,sha256=snoyJKvZ1crgF2fp0zexwNPnV_E63RfyRIsMAZdrKNY,6995
 osbot_utils/type_safe/steps/Type_Safe__Step__Default_Kwargs.py,sha256=tzKXDUc0HVP5QvCWsmcPuuZodNvQZ9FeMDNI2x00Ngw,1943
 osbot_utils/type_safe/steps/Type_Safe__Step__Default_Value.py,sha256=b5vsgM8eg9yq2KM0wRMntVHma6OhN_HnU76LxhEIpoA,4483
 osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py,sha256=AguNcZwKKnyNY87bSAF1xLwYW5h_IDfUad70QqIiK3I,14622
-osbot_utils/type_safe/steps/Type_Safe__Step__Init.py,sha256=dQRwFxEMdmoW2ogmYZ6ZxLOvt1XnALx41LPpIB6yp3s,4473
+osbot_utils/type_safe/steps/Type_Safe__Step__Init.py,sha256=wBdShMavx8Ja5IACyW8dP3_fq_iqrMp8HHziOqjgxqU,4483
 osbot_utils/type_safe/steps/Type_Safe__Step__Set_Attr.py,sha256=Nm1cleC-IDez6HFDejTfMprrnOfTvmEopO_pW6w1vFM,5507
 osbot_utils/type_safe/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/validators/Type_Safe__Validator.py,sha256=cJIPSBarjV716SZUOLvz7Mthjk-aUYKUQtRDtKUBmN4,779
@@ -426,8 +432,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=D2jMsR4GCqKXka6mERWlFlF_-L6bTp87Q1u4_8a3Gac,8
-osbot_utils-2.62.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.62.0.dist-info/METADATA,sha256=Tv5eyV42q8-AugMV48XSad5KlGiBsNe-V__dipVAkko,1329
-osbot_utils-2.62.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.62.0.dist-info/RECORD,,
+osbot_utils/version,sha256=Ik_Z1_68qStKaUrjNMdT-_2K34-svwqhzWn_iKWEiAM,8
+osbot_utils-2.64.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.64.0.dist-info/METADATA,sha256=NVqO8V4OXl0l6YXdNQCbsspZ4wle5_jgH97qimTST9M,1329
+osbot_utils-2.64.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.64.0.dist-info/RECORD,,