osbot-utils 2.62.0__tar.gz → 2.63.0__tar.gz

{osbot_utils-2.62.0 → osbot_utils-2.63.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.62.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.62.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.62.0 → osbot_utils-2.63.0}/README.md

@@ -2,7 +2,7 @@
 
 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.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.62.0 → osbot_utils-2.63.0}/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-2.62.0 → osbot_utils-2.63.0}/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-2.62.0 → osbot_utils-2.63.0}/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-2.62.0 → osbot_utils-2.63.0}/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-2.63.0/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-2.62.0 → osbot_utils-2.63.0}/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-2.62.0 → osbot_utils-2.63.0}/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-2.62.0 → osbot_utils-2.63.0}/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-2.63.0/osbot_utils/version

@@ -0,0 +1 @@
+v2.63.0

{osbot_utils-2.62.0 → osbot_utils-2.63.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v2.62.0"
+version     = "v2.63.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-2.62.0/osbot_utils/type_safe/Type_Safe__Primitive.py

@@ -1,28 +0,0 @@
-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 __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 __repr__(self):                                                     # Enhanced repr to show type information in assertions
-        value_repr = super().__repr__()
-        return f"{type(self).__name__}({value_repr})"
-

osbot_utils-2.62.0/osbot_utils/version

@@ -1 +0,0 @@
-v2.62.0