osbot-utils 2.58.0__py3-none-any.whl → 2.60.0__py3-none-any.whl

osbot_utils/helpers/ast/Ast_Base.py

@@ -1,11 +1,11 @@
 import ast
 import inspect
 
-from osbot_utils.utils.Dev import pprint, jprint
-from osbot_utils.utils.Exceptions import syntax_error
-from osbot_utils.utils.Files import is_file, file_contents
-from osbot_utils.utils.Objects import obj_data, obj_info
-from osbot_utils.utils.Str import str_dedent
+from osbot_utils.utils.Dev          import pprint, jprint
+from osbot_utils.utils.Exceptions   import syntax_error
+from osbot_utils.utils.Files        import is_file, file_contents
+from osbot_utils.utils.Objects      import obj_data, obj_info
+from osbot_utils.utils.Str          import str_dedent
 
 
 class Ast_Base:

osbot_utils/helpers/html/Html__To__Html_Document.py

@@ -3,13 +3,12 @@ from osbot_utils.helpers.html.Html__To__Html_Dict           import Html__To__Htm
 from osbot_utils.helpers.html.schemas.Schema__Html_Document import Schema__Html_Document
 from osbot_utils.type_safe.Type_Safe                        import Type_Safe
 
-
 class Html__To__Html_Document(Type_Safe):
     html: str
     html__dict    : dict
     html__document: Schema__Html_Document
 
-    def convert(self):
+    def convert(self) -> Schema__Html_Document:
         if self.html:
             html__dict =  Html__To__Html_Dict(self.html).convert()
             if html__dict:

osbot_utils/helpers/html/schemas/Schema__Html_Node.py

@@ -4,7 +4,7 @@ from osbot_utils.type_safe.Type_Safe                          import Type_Safe
 
 
 class Schema__Html_Node(Type_Safe):
-    attrs    : Dict[str, Optional[str]]                                               # HTML attributes (e.g., {'class': 'container'})
+    attrs    : Dict[str, Optional[str]]                                     # HTML attributes (e.g., {'class': 'container'}) # todo: see what Safe_Ster we can use for these name attrs
     nodes    : List[Union['Schema__Html_Node', Schema__Html_Node__Data]]    # Child nodes (recursive structure)
-    tag      : str                                                          # HTML tag name (e.g., 'div', 'meta', 'title')
+    tag      : str                                                          # HTML tag name (e.g., 'div', 'meta', 'title')  # todo: see what Safe_Ster we can use for the tag
 

osbot_utils/helpers/safe_float/Safe_Float.py

@@ -0,0 +1,155 @@
+import math
+from decimal import Decimal, ROUND_HALF_UP, InvalidOperation
+from typing import Optional, Union
+
+class Safe_Float(float):                             # Base class for type-safe floats with validation rules
+
+    min_value      : Optional[float] = None
+    max_value      : Optional[float] = None
+    allow_none     : bool            = True
+    allow_bool     : bool            = False
+    allow_str      : bool            = True
+    allow_int      : bool            = True
+    strict_type    : bool            = False
+    decimal_places : Optional[int]   = None
+
+    # Precision handling options
+    use_decimal    : bool            = False
+    epsilon        : float           = 1e-9
+    round_output   : bool            = True
+    clamp_to_range : bool            = False
+
+    def __new__(cls, value: Optional[Union[float, int, str]] = None) -> 'Safe_Float':
+        if value is None:
+            if cls.allow_none:
+                return super().__new__(cls, 0.0)
+            else:
+                raise ValueError(f"{cls.__name__} does not allow None values")
+
+        # Store original value for range checking
+        original_value = value
+
+        # Convert to float
+        if isinstance(value, str):
+            if not cls.allow_str:
+                raise TypeError(f"{cls.__name__} does not allow string conversion")
+            try:
+                if cls.use_decimal:
+                    value = Decimal(value)
+                else:
+                    value = float(value)
+            except (ValueError, InvalidOperation):
+                raise ValueError(f"Cannot convert '{value}' to float")
+        elif isinstance(value, bool):
+            if not cls.allow_bool:
+                raise TypeError(f"{cls.__name__} does not allow boolean values")
+            value = float(value)
+        elif isinstance(value, int):
+            if not cls.allow_int:
+                raise TypeError(f"{cls.__name__} does not allow integer conversion")
+            if cls.use_decimal:
+                value = Decimal(value)
+            else:
+                value = float(value)
+        elif isinstance(value, float):
+            if math.isinf(value):
+                raise ValueError(f"{cls.__name__} does not allow infinite values")
+            if math.isnan(value):
+                raise ValueError(f"{cls.__name__} does not allow NaN values")
+
+            if cls.use_decimal:
+                value = Decimal(str(value))
+        elif not isinstance(value, (float, Decimal)):
+            raise TypeError(f"{cls.__name__} requires a float value, got {type(value).__name__}")
+
+        # Get numeric value for range checking (before rounding)
+        check_value = float(value) if isinstance(value, Decimal) else value
+
+        # Range validation BEFORE rounding (unless clamping)
+        if not cls.clamp_to_range:
+            if cls.min_value is not None and check_value < cls.min_value:
+                raise ValueError(f"{cls.__name__} must be >= {cls.min_value}, got {check_value}")
+            if cls.max_value is not None and check_value > cls.max_value:
+                raise ValueError(f"{cls.__name__} must be <= {cls.max_value}, got {check_value}")
+
+        # NOW do rounding
+        if isinstance(value, Decimal) and cls.decimal_places is not None:
+            value = value.quantize(Decimal(f'0.{"0" * cls.decimal_places}'), rounding=ROUND_HALF_UP)
+
+        if isinstance(value, Decimal):
+            value = float(value)
+
+        # Check again for special values
+        if math.isinf(value):
+            raise ValueError(f"{cls.__name__} does not allow infinite values")
+        if math.isnan(value):
+            raise ValueError(f"{cls.__name__} does not allow NaN values")
+
+        # Clean up floating point errors (only if not already handled by Decimal)
+        if cls.round_output and cls.decimal_places is not None and not cls.use_decimal:
+            value = cls.__clean_float(value, cls.decimal_places)
+
+        # Handle clamping AFTER rounding
+        if cls.clamp_to_range:
+            if cls.min_value is not None and value < cls.min_value:
+                value = cls.min_value
+            if cls.max_value is not None and value > cls.max_value:
+                value = cls.max_value
+
+        return super().__new__(cls, value)
+
+    def __truediv__(self, other):
+        # Simple and safe - no special handling for infinity
+        if float(other) == 0:
+            raise ZeroDivisionError(f"{self.__class__.__name__} division by zero")
+
+        if self.use_decimal:
+            result = float(Decimal(str(float(self))) / Decimal(str(float(other))))
+        else:
+            result = float(self) / float(other)
+
+        # Check for overflow/underflow
+        if math.isinf(result) or math.isnan(result):
+            raise OverflowError(f"Division resulted in {result}")
+
+        if self.round_output and self.decimal_places is not None:
+            result = self.__clean_float(result, self.decimal_places)
+
+        try:
+            return self.__class__(result)
+        except (ValueError, TypeError):
+            return result
+
+    @classmethod
+    def __clean_float(cls, value: float, decimal_places: int) -> float:             # Clean up floating point representation errors
+        rounded = round(value, decimal_places + 2)                                  # First, round to eliminate tiny errors
+
+        # Check if very close to a clean decimal
+        str_val = f"{rounded:.{decimal_places + 2}f}"
+        if str_val.endswith('999999') or str_val.endswith('000001'):
+            # Use Decimal for exact rounding
+            d = Decimal(str(value))
+            return float(d.quantize(Decimal(f'0.{"0" * decimal_places}'), rounding=ROUND_HALF_UP))
+
+        return round(value, decimal_places) if decimal_places else value
+
+    def __mul__(self, other):
+        if self.use_decimal:
+            result = float(Decimal(str(float(self))) * Decimal(str(float(other))))
+        else:
+            result = float(self) * float(other)
+
+        if self.round_output and self.decimal_places is not None:
+            if not (math.isinf(result) or math.isnan(result)):
+                result = self.__clean_float(result, self.decimal_places)
+
+        try:
+            return self.__class__(result)
+        except (ValueError, TypeError):
+            return result
+
+    def __eq__(self, other):
+        """Equality with epsilon tolerance"""
+        if isinstance(other, (int, float)):
+            return abs(float(self) - float(other)) < self.epsilon
+        return super().__eq__(other)

osbot_utils/helpers/safe_float/Safe_Float__Engineering.py

@@ -0,0 +1,7 @@
+from osbot_utils.helpers.safe_float.Safe_Float import Safe_Float
+
+class Safe_Float__Engineering(Safe_Float):          # Engineering calculations with controlled precision
+    #decimal_places  = 6
+    epsilon         = 1e-6
+    round_output    = True
+    use_decimal     = False                         # Performance over exactness

osbot_utils/helpers/safe_float/Safe_Float__Money.py

@@ -0,0 +1,11 @@
+# Safe_Float__Money.py
+from osbot_utils.helpers.safe_float.Safe_Float import Safe_Float
+
+
+class Safe_Float__Money(Safe_Float):    # Money calculations with exact decimal arithmetic
+    decimal_places  = 2
+    use_decimal     = True              # Use Decimal internally
+    allow_inf       = False
+    allow_nan       = False
+    min_value       = 0.0
+    round_output    = True

osbot_utils/helpers/safe_float/Safe_Float__Percentage_Exact.py

@@ -0,0 +1,9 @@
+from osbot_utils.helpers.safe_float.Safe_Float import Safe_Float
+
+
+class Safe_Float__Percentage_Exact(Safe_Float):         # Exact percentage calculations
+    min_value       = 0.0
+    max_value       = 100.0
+    decimal_places  = 2
+    use_decimal     = True
+    round_output    = True

osbot_utils/helpers/safe_int/Safe_Int.py

@@ -0,0 +1,77 @@
+from typing import Optional, Union
+
+from osbot_utils.helpers.safe_float.Safe_Float import Safe_Float
+
+
+class Safe_Int(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)
+    allow_none     : bool          = True    # Whether None is allowed as input
+    allow_bool     : bool          = False   # Whether bool is allowed as input
+    allow_str      : bool          = True    # Whether string conversion is allowed
+    strict_type    : bool          = False   # If True, only accept int type (no conversions)
+
+    def __new__(cls, value: Optional[Union[int, str]] = None) -> 'Safe_Int':
+        # Handle None input
+        if value is None:
+            if cls.allow_none:
+                return super().__new__(cls, 0)  # Default to 0 for None
+            else:
+                raise ValueError(f"{cls.__name__} does not allow None values")
+
+        # Strict type checking
+        if cls.strict_type and not isinstance(value, int):
+            raise TypeError(f"{cls.__name__} requires int type, got {type(value).__name__}")
+
+        # Type conversion
+        if isinstance(value, str):
+            if not cls.allow_str:
+                raise TypeError(f"{cls.__name__} does not allow string conversion")
+            try:
+                value = int(value)
+            except ValueError:
+                raise ValueError(f"Cannot convert '{value}' to integer")
+
+        elif isinstance(value, bool):
+            if not cls.allow_bool:
+                raise TypeError(f"{cls.__name__} does not allow boolean values")
+            value = int(value)
+
+        elif not isinstance(value, int):
+            raise TypeError(f"{cls.__name__} requires an integer value, got {type(value).__name__}")
+
+        # Range validation
+        if cls.min_value is not None and value < cls.min_value:
+            raise ValueError(f"{cls.__name__} must be >= {cls.min_value}, got {value}")
+
+        if cls.max_value is not None and value > cls.max_value:
+            raise ValueError(f"{cls.__name__} must be <= {cls.max_value}, got {value}")
+
+        return super().__new__(cls, value)
+
+    # Arithmetic operations that maintain type safety
+    def __add__(self, other):
+        result = super().__add__(other)
+        try:
+            return self.__class__(result)
+        except (ValueError, TypeError):
+            return result  # Return plain int if validation fails
+
+    def __sub__(self, other):
+        result = super().__sub__(other)
+        try:
+            return self.__class__(result)
+        except (ValueError, TypeError):
+            return result
+
+    def __mul__(self, other):
+        result = super().__mul__(other)
+        try:
+            return self.__class__(result)
+        except (ValueError, TypeError):
+            return result
+
+    def __truediv__(self, other):
+        result = super().__truediv__(other)
+        return Safe_Float(result)

osbot_utils/helpers/safe_int/Safe_Int__Byte.py

@@ -0,0 +1,11 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+TYPE_SAFE_INT__BYTE__MIN_VALUE = 0
+TYPE_SAFE_INT__BYTE__MAX_VALUE = 255
+
+class Safe_Int__Byte(Safe_Int):
+    """Single byte value (0-255)"""
+
+    min_value = TYPE_SAFE_INT__BYTE__MIN_VALUE
+    max_value = TYPE_SAFE_INT__BYTE__MAX_VALUE
+    allow_bool = False

osbot_utils/helpers/safe_int/Safe_Int__FileSize.py

@@ -0,0 +1,19 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+TYPE_SAFE_INT__FILE_SIZE__MIN_VALUE = 0
+TYPE_SAFE_INT__FILE_SIZE__MAX_VALUE = 2**63 - 1         # Max file size on most systems
+
+class Safe_Int__FileSize(Safe_Int):                     # File size in bytes
+
+    min_value = TYPE_SAFE_INT__FILE_SIZE__MIN_VALUE
+    max_value = TYPE_SAFE_INT__FILE_SIZE__MAX_VALUE
+    allow_bool = False
+
+    def to_kb(self) -> float:
+        return self / 1024
+
+    def to_mb(self) -> float:
+        return self / (1024 * 1024)
+
+    def to_gb(self) -> float:
+        return self / (1024 * 1024 * 1024)

osbot_utils/helpers/safe_int/Safe_Int__Percentage.py

@@ -0,0 +1,10 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+TYPE_SAFE_INT__PERCENTAGE__MIN_VALUE = 0
+TYPE_SAFE_INT__PERCENTAGE__MAX_VALUE = 100
+
+class Safe_Int__Percentage(Safe_Int):           # Percentage value (0-100)
+
+    min_value = TYPE_SAFE_INT__PERCENTAGE__MIN_VALUE
+    max_value = TYPE_SAFE_INT__PERCENTAGE__MAX_VALUE
+    allow_bool = False

osbot_utils/helpers/safe_int/Safe_Int__Port.py

@@ -0,0 +1,11 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+TYPE_SAFE_INT__PORT__MIN_VALUE = 0
+TYPE_SAFE_INT__PORT__MAX_VALUE = 65535
+
+class Safe_Int__Port(Safe_Int):                         # Network port number (0-65535)
+
+    min_value  = TYPE_SAFE_INT__PORT__MIN_VALUE
+    max_value  = TYPE_SAFE_INT__PORT__MAX_VALUE
+    allow_bool = False
+    allow_none = False                                  # don't allow 0 as port value since that is a really weird value for a port

osbot_utils/helpers/safe_int/Safe_Int__UInt.py

@@ -0,0 +1,7 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+class Safe_Int__UInt(Safe_Int):             # Unsigned Integer - only accepts non-negative integer values
+
+    min_value  = 0       # Unsigned means >= 0
+    max_value  = None    # No upper limit by default
+    allow_bool = False  # Don't allow True/False as 1/0

osbot_utils/helpers/safe_int/__init__.py

@@ -0,0 +1,10 @@
+from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+
+TYPE_SAFE_INT__BYTE__MIN_VALUE = 0
+TYPE_SAFE_INT__BYTE__MAX_VALUE = 255
+
+class Safe_Int__Byte(Safe_Int): # Single byte value (0-255)
+
+    min_value = TYPE_SAFE_INT__BYTE__MIN_VALUE
+    max_value = TYPE_SAFE_INT__BYTE__MAX_VALUE
+    allow_bool = False

osbot_utils/helpers/safe_str/Safe_Str.py

@@ -21,7 +21,7 @@ class Safe_Str(str):
             if cls.allow_empty:
                 value = ""
             else:
-                raise ValueError("Value cannot be None when allow_empty is False")
+                raise ValueError(f"in {cls.__name__}, value cannot be None when allow_empty is False") from None
 
         if not isinstance(value, str):                                                                                  # Convert to string if not already
             value = str(value)

osbot_utils/helpers/safe_str/http/Safe_Str__Http__Content_Type.py

@@ -0,0 +1,12 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__HTTP__CONTENT_TYPE__REGEX = re.compile(r'[^a-zA-Z0-9/\-+.;= ]')
+TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH = 256
+
+class Safe_Str__Http__Content_Type(Safe_Str):
+    regex                      = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__REGEX
+    max_length                 = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH
+    allow_empty                = False
+    trim_whitespace            = True
+    allow_all_replacement_char = False

osbot_utils/helpers/safe_str/http/Safe_Str__Http__ETag.py

@@ -0,0 +1,10 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__HTTP__ETAG__REGEX = re.compile(r'[^a-zA-Z0-9"\/\-_.:]')  # Allow alphanumerics, quotes, slashes, hyphens, underscores, periods, colons
+TYPE_SAFE_STR__HTTP__ETAG__MAX_LENGTH = 128
+
+class Safe_Str__Http__ETag(Safe_Str):
+    regex                      = TYPE_SAFE_STR__HTTP__ETAG__REGEX
+    max_length                 = TYPE_SAFE_STR__HTTP__ETAG__MAX_LENGTH
+    trim_whitespace            = True

osbot_utils/helpers/safe_str/http/Safe_Str__Http__Last_Modified.py

@@ -0,0 +1,10 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__HTTP__LAST_MODIFIED__REGEX = re.compile(r'[^a-zA-Z0-9:, -]')
+TYPE_SAFE_STR__HTTP__LAST_MODIFIED__MAX_LENGTH = 64
+
+class Safe_Str__Http__Last_Modified(Safe_Str):
+    regex                      = TYPE_SAFE_STR__HTTP__LAST_MODIFIED__REGEX
+    max_length                 = TYPE_SAFE_STR__HTTP__LAST_MODIFIED__MAX_LENGTH
+    trim_whitespace            = True

osbot_utils/helpers/safe_str/http/Safe_Str__Http__Text.py

@@ -0,0 +1,35 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+
+
+TYPE_SAFE_STR__TEXT__MAX_LENGTH = 1048576           # Define the size constant - 1 megabyte in bytes
+
+# A more permissive regex that primarily filters out:
+# - NULL byte (U+0000)
+# - Control characters (U+0001 to U+0008, U+000B to U+000C, U+000E to U+001F)
+# - Some potentially problematic characters in various contexts
+# But allows:
+# - All standard printable ASCII characters
+# - Tab (U+0009), Line Feed (U+000A), and Carriage Return (U+000D)
+# - A wide range of punctuation, symbols, and Unicode characters for international text
+
+TYPE_SAFE_STR__HTTP__TEXT__REGEX = re.compile(r'[\x00\x01-\x08\x0B\x0C\x0E-\x1F\x7F]')
+
+class Safe_Str__Http__Text(Safe_Str):
+    """
+    Safe string class for general text content with a 1MB limit.
+    Allows a wide range of characters suitable for natural language text,
+    including international characters, while filtering out control characters
+    and other potentially problematic sequences.
+    """
+    max_length                  = TYPE_SAFE_STR__TEXT__MAX_LENGTH
+    regex                       = TYPE_SAFE_STR__HTTP__TEXT__REGEX
+    trim_whitespace             = True              # Trim leading/trailing whitespace
+    normalize_newlines          = True              # Option to normalize different newline styles
+
+    def __new__(cls, value=None):
+
+        if cls.normalize_newlines and value is not None and isinstance(value, str):         # Handle newline normalization before passing to parent class
+            value = value.replace('\r\n', '\n').replace('\r', '\n')                         # Normalize different newline styles to \n
+
+        return super().__new__(cls, value)                                                  # Now call the parent implementation

osbot_utils/type_safe/shared/Type_Safe__Validation.py

@@ -285,7 +285,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, str):
+                        if not 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/utils/Functions.py

@@ -25,13 +25,13 @@ def function_name(function):
     if isinstance(function, types.FunctionType):
         return function.__name__
 
-def function_source_code(function):
-    if isinstance(function, types.FunctionType):
-        source_code = inspect.getsource(function)
+def function_source_code(target):
+    if isinstance(target, (types.FunctionType, types.MethodType)):
+        source_code = inspect.getsource(target)
         source_code = textwrap.dedent(source_code).strip()
         return source_code
-    elif isinstance(function, str):
-        return function
+    elif isinstance(target, str):                               # todo: see if we really need this logic (or we just return none when "target" is a str)
+        return target
     return None
 
 def get_line_number(function):
@@ -110,4 +110,5 @@ def type_file(target):
 
 
 function_line_number = get_line_number
-method_line_number   = get_line_number
+method_line_number   = get_line_number
+method_source_code   = function_source_code

osbot_utils/version

@@ -1 +1 @@
-v2.58.0
+v2.60.0

{osbot_utils-2.58.0.dist-info → osbot_utils-2.60.0.dist-info}/METADATA

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

@@ -51,7 +51,7 @@ osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbG
 osbot_utils/helpers/Zip_Bytes.py,sha256=Bf17NPS_yxrzI_4FsCxkjlhS9ELJK3kisY-jHQPQVgw,4287
 osbot_utils/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/ast/Ast.py,sha256=lcPQOSxXI6zgmMnIVF9WM6ISqViWX-sq4d_UC0CDG8s,1155
-osbot_utils/helpers/ast/Ast_Base.py,sha256=5rHMupBlN_n6lOC31UnSW_lWqxqxaE31v0gn-t32OgQ,3708
+osbot_utils/helpers/ast/Ast_Base.py,sha256=x3UGJsxkIkMlkzt59eZYZG9NmvvODO5jaRBEeiqSaSA,3740
 osbot_utils/helpers/ast/Ast_Data.py,sha256=EL-6lkNDMe_BKBwFP1sJW-Y8t6TXYYv0uGdlxix4Tyg,697
 osbot_utils/helpers/ast/Ast_Load.py,sha256=ZO2QjhQ13j1m4MwAVbbdAoQ4UoUfzuU6E_RobkhZVpI,2100
 osbot_utils/helpers/ast/Ast_Merge.py,sha256=An_u2E906DrMlAl83VyTNLKBSc0uEm25RWLRZsci2rk,848
@@ -179,7 +179,7 @@ osbot_utils/helpers/html/Html_Dict__To__Html.py,sha256=jLizQHHfSLkOkdzbfSyPuHFys
 osbot_utils/helpers/html/Html_Dict__To__Html_Document.py,sha256=hpN-3IJjYNly1tcCWp5JuLsE_idawgcYpMpXcwFnqHI,2135
 osbot_utils/helpers/html/Html_Dict__To__Html_Tags.py,sha256=MfXW-tfTBA7DiGJfUX1HB4-Y1F1kxdIhTyglYHUblOs,5425
 osbot_utils/helpers/html/Html__To__Html_Dict.py,sha256=VDaTOkrsidhLUj2Uuj7YdP0VYlLm6inFaRKybeC8ppg,4340
-osbot_utils/helpers/html/Html__To__Html_Document.py,sha256=uOXJ6pDaSIprZx2Ck9i01Q0Jj5SrPJKyiCLj42E0PoA,862
+osbot_utils/helpers/html/Html__To__Html_Document.py,sha256=xVbIT3TaxZPt4cz3lO4WvSru7FyWI1p36qdXp6HGC8o,886
 osbot_utils/helpers/html/Html__To__Html_Tag.py,sha256=Qz6he08DwfYkYM_krt_FCVtEWgw6_9bs5j5CoC1FCQQ,566
 osbot_utils/helpers/html/Tag__Base.py,sha256=geD7TpA3lHrSiaoLsViH2rcjrqZkMxNpDOhLx3HYbSk,4470
 osbot_utils/helpers/html/Tag__Body.py,sha256=U3UNVs1mNBsJ_kG_-OtwYPi-YzFb4Y2w4vIsvAn0W3g,109
@@ -193,7 +193,7 @@ osbot_utils/helpers/html/Tag__Style.py,sha256=wRZ8DN1HVCtrnL4Flz82oByqJOy8Th40Eh
 osbot_utils/helpers/html/Tag__Text.py,sha256=Pqf96QGwX9wdGqlwBvWYHWz9Qqi-oZrkgEzHQm6LzdY,241
 osbot_utils/helpers/html/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/html/schemas/Schema__Html_Document.py,sha256=227IP9kfQ7FH7bhd-LsPsppPo-mhwC58BcGYWsy0WwQ,381
-osbot_utils/helpers/html/schemas/Schema__Html_Node.py,sha256=LqHGQsQm7z4VLaXcQr2PaUNglpNnMRetzxVBiiwrjuI,628
+osbot_utils/helpers/html/schemas/Schema__Html_Node.py,sha256=dz_LI9xzoz6_Gfh6aQbGBeN3IHZLlWVjESIegNz9vxY,728
 osbot_utils/helpers/html/schemas/Schema__Html_Node__Data.py,sha256=T0S-MF-aw91fZCoU0vkDH0Ni_4oAyiXGdIMsHXdt4fs,449
 osbot_utils/helpers/html/schemas/Schema__Html_Node__Data__Type.py,sha256=mbYivcm6BfN5-oeCyl6gjbnSKs_b_t-G2H1rpSK6nUY,90
 osbot_utils/helpers/html/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -241,15 +241,32 @@ 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_str/Safe_Str.py,sha256=xkc0XhDWcln-3-yENqpQcPgiDewq-l4sAiqW1a2MRyU,3345
+osbot_utils/helpers/safe_float/Safe_Float.py,sha256=p0To2jrseu4xN4EhhgIR-1ncpJ21X6pxchTI-iHakOQ,6517
+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__Byte.py,sha256=D95ZDydTOxMt3FAnUq5llND__3Loju_G3Ge1dVhGMck,318
+osbot_utils/helpers/safe_int/Safe_Int__FileSize.py,sha256=mqYoyM2lTUMM4PzkjyXBpsA9dFQY53roNf2649dK1DA,592
+osbot_utils/helpers/safe_int/Safe_Int__Percentage.py,sha256=hkOhv4kkEYs3xExYv2fQfkPi4lbYG6cTHxz-2wiSqL8,349
+osbot_utils/helpers/safe_int/Safe_Int__Port.py,sha256=2mXh5QM_aqzPLgqT88v6R3CLG4E6K5EmqtGStIKRLmo,474
+osbot_utils/helpers/safe_int/Safe_Int__UInt.py,sha256=3S4k3Jw6PIIgWw6i6Dmhg25VnsEvAL_7tPCQEvkOKR4,322
+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__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
-osbot_utils/helpers/safe_str/Safe_Str__Html.py,sha256=4_UxGEIkqV_Zeh77nXoO2OUy5SS6gvN3xSwA32DyWs0,662
 osbot_utils/helpers/safe_str/Safe_Str__Text.py,sha256=QxuWqF8hNYdOPDn3Yac86h_1ZaX-THbTBDakberiJcs,313
 osbot_utils/helpers/safe_str/Safe_Str__Text__Dangerous.py,sha256=6-fkXBuWgjz70eQicD07f38eEuKqNzJzaFFY6hozhNQ,388
 osbot_utils/helpers/safe_str/Safe_Str__Url.py,sha256=4l46AAe5Dy_P_W6d-_3pwtXuehG_Wczq1dC5sOOzg_g,549
 osbot_utils/helpers/safe_str/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/safe_str/http/Safe_Str__Html.py,sha256=4_UxGEIkqV_Zeh77nXoO2OUy5SS6gvN3xSwA32DyWs0,662
+osbot_utils/helpers/safe_str/http/Safe_Str__Http__Content_Type.py,sha256=HURT4n17LmKbcqODsNwhu_D0lI5LpUL8I5t9aqGAZhQ,516
+osbot_utils/helpers/safe_str/http/Safe_Str__Http__ETag.py,sha256=5cAfIqebraUnVKZJq3CzXzsFdHGy06TznO36Dc6b5A0,477
+osbot_utils/helpers/safe_str/http/Safe_Str__Http__Last_Modified.py,sha256=FBcPM4h3ldN0F_cSISGZgdidWpjKLCOOPq9sWVGUCzg,438
+osbot_utils/helpers/safe_str/http/Safe_Str__Http__Text.py,sha256=w0UPkVnQz41BN9asgDUZ4q6pSQUtzNa-4Sjcl56WTCM,1788
+osbot_utils/helpers/safe_str/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/sqlite/Capture_Sqlite_Error.py,sha256=GSuRYgs1yKQjxMszPoaI7fsfMfuUqhb64AaIysRE6Cs,1747
 osbot_utils/helpers/sqlite/Sqlite__Cursor.py,sha256=4Im0pCOiERX6Nnf6iagRlSvTR3CPjyPVkdx4NMQV0P0,3342
 osbot_utils/helpers/sqlite/Sqlite__Database.py,sha256=ORjRUD-xSvf89kDMQ70q7wBlbV5pdKtDerjE6gDN_fg,5616
@@ -367,7 +384,7 @@ osbot_utils/type_safe/shared/Type_Safe__Json_Compressor__Type_Registry.py,sha256
 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__Shared__Variables.py,sha256=SuZGl9LryQX6IpOE0I_lbzClT-h17UNylC__-M8ltTY,129
-osbot_utils/type_safe/shared/Type_Safe__Validation.py,sha256=ZBuirH8nTlmpsW8GER8Dz2MA64DbMN_ZaHfylmk8TOA,19227
+osbot_utils/type_safe/shared/Type_Safe__Validation.py,sha256=zAQHly65XeOCfASOdlCmkYIgh_MYh-dyPzavF-Pua60,19240
 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
@@ -389,7 +406,7 @@ osbot_utils/utils/Dev.py,sha256=eaQ87ZcMRRcxgzA-f7OO8HjjWhbE6L_edwvXiwFZvIQ,1291
 osbot_utils/utils/Env.py,sha256=rBksAy6k-J5oAJp-S_JedVlcj1b2VK8V3zsQbacopMc,6076
 osbot_utils/utils/Exceptions.py,sha256=KyOUHkXQ_6jDTq04Xm261dbEZuRidtsM4dgzNwSG8-8,389
 osbot_utils/utils/Files.py,sha256=YwfXMeU1jfDzYvZJGy0bWHvvduTuTnftBNlAnpsXDzw,23013
-osbot_utils/utils/Functions.py,sha256=0E6alPJ0fJpBiJgFOWooCOi265wSRyxxXAJ5CELBnso,3498
+osbot_utils/utils/Functions.py,sha256=VoTrAbCHt6hulz6hVz3co8w2xoOS8wE04wyHc5_cC1c,3671
 osbot_utils/utils/Http.py,sha256=pLDwq0Jd4Zmpps0gEzXTbeycSFRXMN8W-DprNpYq9A0,8189
 osbot_utils/utils/Int.py,sha256=PmlUdU4lSwf4gJdmTVdqclulkEp7KPCVUDO6AcISMF4,116
 osbot_utils/utils/Json.py,sha256=TvfDoXwOkWzWH-9KMnme5C7iFsMZOleAeue92qmkH6g,8831
@@ -408,8 +425,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=U8cnypqceB-I0lPuD9FygqqfepVZIr4jtiKTthZNNmY,8
-osbot_utils-2.58.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.58.0.dist-info/METADATA,sha256=a1wQUYcqT0cscIPzL1lfUFAVhjUA9MtY2LgkDZYpyO8,1329
-osbot_utils-2.58.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.58.0.dist-info/RECORD,,
+osbot_utils/version,sha256=D9uXwX3FHdetilkBF7SobVFVi0hZtTHmuPxn_3li-ms,8
+osbot_utils-2.60.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.60.0.dist-info/METADATA,sha256=fllKiqMg4tuh-o1z-XbK-BRcd5ydmtaYAGRy8F-Qv_4,1329
+osbot_utils-2.60.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.60.0.dist-info/RECORD,,