osbot-utils 2.61.0__py3-none-any.whl → 2.63.0__py3-none-any.whl

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/Random_Guid.py

@@ -1,6 +1,6 @@
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
-
-class Random_Guid(str):
+class Random_Guid(Type_Safe__Primitive, str):
     def __new__(cls, value=None):
         from osbot_utils.utils.Misc import random_guid, is_guid
 
@@ -10,5 +10,5 @@ class Random_Guid(str):
             return str.__new__(cls, value)
         raise ValueError(f'in Random_Guid: value provided was not a Guid: {value}')
 
-    def __str__(self):
-        return self
+    # def __str__(self):
+    #     return self

osbot_utils/helpers/Safe_Id.py

@@ -1,14 +1,18 @@
-from osbot_utils.utils.Misc import random_id_short
-from osbot_utils.utils.Str  import safe_id
+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
 
 SAFE_ID__MAX_LENGTH = 512
 
-class Safe_Id(str):
+class Safe_Id(Type_Safe__Primitive, str):
     def __new__(cls, value=None, max_length=SAFE_ID__MAX_LENGTH):
         if value is None:
             value = safe_id(random_id_short('safe-id'))
         sanitized_value = safe_id(value, max_length=max_length)
         return str.__new__(cls, sanitized_value)
 
-    def __str__(self):
-        return self
+    # def __str__(self):
+    #     return self
+
+
+# note: here is the regex applied on safe_id:  REGEX__SAFE_ID_REGEX       = re.compile(r'[^a-zA-Z0-9_-]')

osbot_utils/helpers/Timestamp_Now.py

@@ -1,5 +1,6 @@
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
-class Timestamp_Now(int):
+class Timestamp_Now(Type_Safe__Primitive, int):
     def __new__(cls, value=None):
         from osbot_utils.utils.Misc import timestamp_now
 

osbot_utils/helpers/safe_float/Safe_Float.py

@@ -1,8 +1,10 @@
 import math
-from decimal import Decimal, ROUND_HALF_UP, InvalidOperation
-from typing import Optional, Union
+from decimal                                    import Decimal, ROUND_HALF_UP, InvalidOperation
+from typing                                     import Optional, Union
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
-class Safe_Float(float):                             # Base class for type-safe floats with validation rules
+
+class Safe_Float(Type_Safe__Primitive, float):                             # Base class for type-safe floats with validation rules
 
     min_value      : Optional[float] = None
     max_value      : Optional[float] = None

osbot_utils/helpers/safe_int/Safe_Int.py

@@ -1,9 +1,9 @@
-from typing import Optional, Union
+from typing                                     import Optional, Union
+from osbot_utils.helpers.safe_float.Safe_Float  import Safe_Float
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
-from osbot_utils.helpers.safe_float.Safe_Float import Safe_Float
 
-
-class Safe_Int(int):            # Base class for type-safe integers with validation rules
+class Safe_Int(Type_Safe__Primitive, int):            # Base class for type-safe integers with validation rules
 
     min_value      : Optional[int] = None    # Minimum allowed value (inclusive)
     max_value      : Optional[int] = None    # Maximum allowed value (inclusive)

osbot_utils/helpers/safe_str/Safe_Str.py

@@ -1,10 +1,11 @@
 import re
-from typing import Optional
+from typing                                     import Optional
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
 TYPE_SAFE__STR__REGEX__SAFE_STR = re.compile(r'[^a-zA-Z0-9]')    # Only allow alphanumerics and numbers
 TYPE_SAFE__STR__MAX_LENGTH      = 512
 
-class Safe_Str(str):
+class Safe_Str(Type_Safe__Primitive, str):
     max_length                : int           = TYPE_SAFE__STR__MAX_LENGTH
     regex                     : re.Pattern    = TYPE_SAFE__STR__REGEX__SAFE_STR
     replacement_char          : str           = '_'

osbot_utils/type_safe/Type_Safe__Base.py

@@ -104,8 +104,25 @@ class Type_Safe__Base:
                 actual_type_name = type_str(type(item))
                 raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-    # def json(self):
-    #     pass
+    def try_convert(self, value, expected_type):    # Try to convert value to expected type using Type_Safe conversion logic.
+
+        if expected_type is Any:                                    # Handle Any type
+            return value
+
+        origin = type_safe_cache.get_origin(expected_type)          # Handle subscripted generics (like Callable, Union, etc.)
+        if origin is not None:
+            return value                                            # Can't convert generic types, let type check handle it
+
+        if isinstance(value, expected_type):        # If already correct type, return as-is
+            return value
+
+        if isinstance(expected_type, type) and type(value) in [str, int, float]:        # For types that are subclasses of built-ins (like Safe_Id extends str)
+            if issubclass(expected_type, type(value)):                                  # Only convert if the value's type is a base class of expected_type. e.g., str → Safe_Id (ok), but not int → str (not ok)
+                return expected_type(value)                                             # convert value to expected_type
+
+
+        # Return original if no conversion possible
+        return value
 
 # todo: see if we should/can move this to the Objects.py file
 def type_str(tp):

osbot_utils/type_safe/Type_Safe__Dict.py

@@ -1,4 +1,5 @@
 from typing                                import Type
+from osbot_utils.type_safe.Type_Safe__List import Type_Safe__List
 from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
@@ -8,15 +9,22 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
         self.expected_key_type   = expected_key_type
         self.expected_value_type = expected_value_type
 
-    def __setitem__(self, key, value):                                  # Check type-safety before allowing assignment.
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)                                     # First try direct lookup
+        except KeyError:
+            converted_key = self.try_convert(key, self.expected_key_type)       # Try converting the key
+            return super().__getitem__(converted_key)                           # and compare again
+
+    def __setitem__(self, key, value):                                          # Check type-safety before allowing assignment.
+        key   = self.try_convert(key  , self.expected_key_type  )
+        value = self.try_convert(value, self.expected_value_type)
         self.is_instance_of_type(key  , self.expected_key_type)
         self.is_instance_of_type(value, self.expected_value_type)
         super().__setitem__(key, value)
 
-    # def __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"
+    def __enter__(self): return self
+    def __exit__ (self, type, value, traceback): pass
 
     def json(self):                                                                         # Convert the dictionary to a JSON-serializable format.
         from osbot_utils.type_safe.Type_Safe import Type_Safe                               # can only import this here to avoid circular imports
@@ -38,3 +46,9 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
             else:                                                                           # Regular values can be used as-is
                 result[key] = value
         return result
+
+    def keys(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_key_type, super().keys())
+
+    def values(self) -> Type_Safe__List:
+        return Type_Safe__List(self.expected_value_type, super().values())

osbot_utils/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)
@@ -10,6 +12,9 @@ class Type_Safe__List(Type_Safe__Base, list):
         expected_type_name = type_str(self.expected_type)
         return f"list[{expected_type_name}] with {len(self)} elements"
 
+    def __enter__(self): return self
+    def __exit__ (self, type, value, traceback): pass
+
     def append(self, item):
         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:  # if self.expected_type is Type_Safe and we have a dict
@@ -18,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

@@ -0,0 +1,64 @@
+class Type_Safe__Primitive:
+
+    __primitive_base__ = None                                                   # Cache the primitive base type at class level
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        for base in cls.__mro__:                                                # Find and cache the primitive base type when the class is created
+            if base in (str, int, float):                                       # for now, we only support str, int, float
+                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)
+        if self.__primitive_base__ and type(other) is self.__primitive_base__:  # Compare with cached primitive base type
+            return super().__eq__(other)
+        return False                                                            # Different types → not equal
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    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 __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

@@ -8,7 +8,7 @@ class Type_Safe__Raise_Exception:
         raise ValueError(exception_message)
 
     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}'"
+        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)
 
 type_safe_raise_exception = Type_Safe__Raise_Exception()

osbot_utils/type_safe/shared/Type_Safe__Validation.py

@@ -4,6 +4,7 @@ import types
 import typing
 from enum                                                      import EnumMeta
 from typing                                                    import Any, Annotated, Optional, get_args, get_origin, ForwardRef, Type, Dict, _GenericAlias
+from osbot_utils.type_safe.Type_Safe__Primitive                import Type_Safe__Primitive
 from osbot_utils.type_safe.shared.Type_Safe__Annotations       import type_safe_annotations
 from osbot_utils.type_safe.shared.Type_Safe__Cache             import type_safe_cache
 from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
@@ -33,6 +34,9 @@ class Type_Safe__Validation:
                 return True
         if target_type is typing.Any:
             return True
+        if isinstance(target_type, type) and issubclass(target_type,Type_Safe__Primitive):
+            if source_type in (int, float, str):
+                return True
         return False
 
     def are_types_magic_mock(self, source_type, target_type):
@@ -277,7 +281,7 @@ class Type_Safe__Validation:
                 actual_type = value
             else:
                 actual_type = type(value)
-            raise ValueError(f"Invalid type for attribute '{name}'. Expected '{expected_type}' but got '{actual_type}'")
+            raise ValueError(f"Invalid type for attribute '{name}'. Expected '{expected_type}' but got '{actual_type}'") from None
 
     # todo: see if need to add cache support to this method     (it looks like this method is not called very often)
     def validate_type_immutability(self, var_name: str, var_type: Any) -> None:                         # Validates that type is immutable or in supported format
@@ -285,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/type_safe/steps/Type_Safe__Step__Set_Attr.py

@@ -1,4 +1,5 @@
 from typing                                                  import get_origin, Annotated, get_args
+from osbot_utils.type_safe.Type_Safe__Primitive              import Type_Safe__Primitive
 from osbot_utils.type_safe.shared.Type_Safe__Cache           import type_safe_cache
 from osbot_utils.type_safe.shared.Type_Safe__Convert         import type_safe_convert
 from osbot_utils.type_safe.shared.Type_Safe__Validation      import type_safe_validation
@@ -9,7 +10,9 @@ class Type_Safe__Step__Set_Attr:
     def resolve_value(self, _self, annotations, name, value):
         if type(value) is dict:
             value = self.resolve_value__dict(_self, name, value)
-        elif type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
+        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)
             value = self.resolve_value__int_str(_self, name, value)
         else:
             value = self.resolve_value__from_origin(value)

osbot_utils/utils/Objects.py

@@ -272,7 +272,9 @@ def serialize_to_dict(obj):
     from enum    import Enum
     from typing  import List
 
-    if isinstance(obj, (str, int, float, bool, bytes, Decimal)) or obj is None:     # todo: add support for objects like datetime
+    if 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
         return obj
     elif isinstance(obj, Enum):
         return obj.name

osbot_utils/version

@@ -1 +1 @@
-v2.61.0
+v2.63.0

{osbot_utils-2.61.0.dist-info → osbot_utils-2.63.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.61.0
+Version: 2.63.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.61.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.63.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.61.0.dist-info → osbot_utils-2.63.0.dist-info}/RECORD

@@ -38,15 +38,15 @@ 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=COu9hcP51vzjk-ErECTFFaOWuOmW0eGJyMu8HXhaRXQ,382
+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=0wPGd9eLzaOCYTSg9yEOal1kPsc8OI9khHkqEw9VQOM,446
+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=k3-SUGYx2jLTXvgZYeECqPRJhVxqWPmW7co1l6r12jk,438
+osbot_utils/helpers/Timestamp_Now.py,sha256=OZwSwmYA1pZAnVglpx2lBL5t8Pu_HxzmYdNEJnmTqKI,536
 osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbGuEN3S94,311
 osbot_utils/helpers/Zip_Bytes.py,sha256=Bf17NPS_yxrzI_4FsCxkjlhS9ELJK3kisY-jHQPQVgw,4287
 osbot_utils/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -241,19 +241,19 @@ osbot_utils/helpers/pubsub/schemas/Schema__PubSub__Client.py,sha256=yOQSn4o1bIsE
 osbot_utils/helpers/pubsub/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/python_compatibility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/python_compatibility/python_3_8.py,sha256=kh846vs3ir8xD0RSARJBOL0xufnt3L_Td3K45lDfqng,161
-osbot_utils/helpers/safe_float/Safe_Float.py,sha256=p0To2jrseu4xN4EhhgIR-1ncpJ21X6pxchTI-iHakOQ,6517
+osbot_utils/helpers/safe_float/Safe_Float.py,sha256=qgmO8S8wFHXA4O3hm4bdamFZ0HkaN_r59hSbUNevHhc,6687
 osbot_utils/helpers/safe_float/Safe_Float__Engineering.py,sha256=2XLh8sLs49WXqyRUzPbZnTQGok-CKR6jjxZCXi5py2A,330
 osbot_utils/helpers/safe_float/Safe_Float__Money.py,sha256=Abh_CX8849rtKgAu-hCxwVxBytb7-I9-chkbYXpQr74,378
 osbot_utils/helpers/safe_float/Safe_Float__Percentage_Exact.py,sha256=l_nGfa2-VCgdBeUXYQAR2wawc4362A9GsCOpWZ3Sdd4,286
 osbot_utils/helpers/safe_float/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/helpers/safe_int/Safe_Int.py,sha256=eXOJjZ8CgXshFQcPVwL1lOdemF8X65Jy0NFJTlt6QG8,3034
+osbot_utils/helpers/safe_int/Safe_Int.py,sha256=Bx_PDuGoLqNgjKMIdmMObAv7u4fw1ISWJlSNkK9kbXI,3168
 osbot_utils/helpers/safe_int/Safe_UInt.py,sha256=lU8TiNNpa9Vwg-FK0btk_bRaV_GYcGpBjHjFAdw5f08,317
 osbot_utils/helpers/safe_int/Safe_UInt__Byte.py,sha256=850zWYmowGE7NlkVocNewphWGXzBeWtVRV_zs2XFrxI,328
 osbot_utils/helpers/safe_int/Safe_UInt__FileSize.py,sha256=pj1_Gf48JVXbnnvx5-YqbQfUsyV_PChVzh1Nnk7PuBY,602
 osbot_utils/helpers/safe_int/Safe_UInt__Percentage.py,sha256=Ck-jiu6NK57Y3ruAjIJ0k-maiKcB2Q7M3t9nKf-8ga8,357
 osbot_utils/helpers/safe_int/Safe_UInt__Port.py,sha256=uISrh8VKXiEQULQ1POU9YK8Di6z_vr0HWjCTpjA0YaY,482
 osbot_utils/helpers/safe_int/__init__.py,sha256=kMU2WMsdQmayBEZugxnJV_wRW3O90bc118sx6iIm_mQ,310
-osbot_utils/helpers/safe_str/Safe_Str.py,sha256=qc_wO1okHamcOOtv6-cvmPvF1Eh1A7-Pk4P4MSzOb24,3375
+osbot_utils/helpers/safe_str/Safe_Str.py,sha256=qR2RDh5cehP_wDDeV5TQahNBwmfcizPFyStALBKD5dw,3509
 osbot_utils/helpers/safe_str/Safe_Str__File__Name.py,sha256=ncjkQ2hAhw0a3UulrCuQsA9ytrFwg5CT1XRJIGChMpY,289
 osbot_utils/helpers/safe_str/Safe_Str__File__Path.py,sha256=K0yBcvH_Ncqiw7tMqjGqaNyWQh1Zs9qxZ-TR8nEIAow,550
 osbot_utils/helpers/safe_str/Safe_Str__Hash.py,sha256=Tb2QeVpVDNWpCJGHNFjZPCQ_ZTaI7Z5BDzi19LiO_cI,952
@@ -365,10 +365,11 @@ osbot_utils/testing/performance/models/Model__Performance_Measure__Measurement.p
 osbot_utils/testing/performance/models/Model__Performance_Measure__Result.py,sha256=k9HJYNLmW6sjRVsfpduSxHFiVANc1zmYtO_Oz9azpW8,755
 osbot_utils/testing/performance/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/Type_Safe.py,sha256=LOWRGOGpnRU2iTRLP47vUoyalK0vjFrWlnaghBIogWg,6267
-osbot_utils/type_safe/Type_Safe__Base.py,sha256=9VfmZzY7aE5rNES7F38YYB7U4BqcUqXET1tABuZDsCk,7634
-osbot_utils/type_safe/Type_Safe__Dict.py,sha256=9TExQtFHQNLdw_ASfQ49i1YhC7fSyCiGdVkK8n-hGlc,2407
-osbot_utils/type_safe/Type_Safe__List.py,sha256=6PIo52QUBu83KhPlvlVOT8tpPpQQkDUGswKKhOxoymg,1707
-osbot_utils/type_safe/Type_Safe__Method.py,sha256=PRV4enbwuD81QKP_5UtUA3OAp0m0xSiUhwkCoseZoq4,15687
+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=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
@@ -382,16 +383,16 @@ 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=9OaPZNZeJzuSvyDqDq-7UBSIlXCdktuxl10C3EEC2Io,876
 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=zAQHly65XeOCfASOdlCmkYIgh_MYh-dyPzavF-Pua60,19240
+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__Set_Attr.py,sha256=VuKHH9QEYlbAL9R4zwQ5dwexx2sFY6wMx52QmF7eqcg,5219
+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
 osbot_utils/type_safe/validators/Validator__Max.py,sha256=pCvYF5Jb_cBgn1ArGhf6FNUB-NGCXPq3D36oYDCyAzg,1275
@@ -413,7 +414,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=kylrLHxWYcsYgA1tCoXYb-TpnuE2PRkhTj2iDleM5YQ,13460
+osbot_utils/utils/Objects.py,sha256=HFYcTM8o53ongj_Ih5Iw4C043DdHnDg7cOCd20JDG70,13587
 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
@@ -425,8 +426,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=A0AXkXECvuIXavsLFlifByi5-p8o9nRkdlWMvuPBgfQ,8
-osbot_utils-2.61.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.61.0.dist-info/METADATA,sha256=j1Zm2RU9ggsy5f74yYySuzeYAKAV2G0IIbnHR9iQyxQ,1329
-osbot_utils-2.61.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.61.0.dist-info/RECORD,,
+osbot_utils/version,sha256=IWixd7YBcbxa1wEG9NtDCaSq5I9PLdGT6l-PYSH_4Nk,8
+osbot_utils-2.63.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.63.0.dist-info/METADATA,sha256=l32825CMqXSK4LT9FOklpDdDAUtX-shMbOiC82HjVh4,1329
+osbot_utils-2.63.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.63.0.dist-info/RECORD,,