osbot-utils 2.87.0__tar.gz → 2.88.0__tar.gz

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.87.0
+Version: 2.88.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.87.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.88.0-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.87.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.88.0-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/osbot_utils/type_safe/Type_Safe.py

@@ -88,7 +88,7 @@ class Type_Safe:
             if value is not None:
                 if hasattr(self,'__annotations__'):  # can only do type safety checks if the class does not have annotations
                     if type_safe_validation.check_if__type_matches__obj_annotation__for_attr(self, key, value) is False:
-                        raise ValueError(f"Invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
+                        raise ValueError(f"On {self.__class__.__name__} invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
                 setattr(self, key, value)
         return self
 

osbot_utils-2.88.0/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Raise_Exception.py

@@ -0,0 +1,18 @@
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
+
+
+class Type_Safe__Raise_Exception:
+
+    def type_mismatch_error__on_instance(self, _self, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
+        exception_message = f"On {_self.__class__.__name__}, invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
+        raise ValueError(exception_message) from None
+
+    def type_mismatch_error__on_type(self, cls, var_name: str, expected_type: type, actual_type: type) -> None:                               # Raises formatted error for type validation failures
+        exception_message = f"On {cls.__name__}, invalid type for attribute '{var_name}'. Expected '{expected_type}' but got '{actual_type}'"
+        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}' and the following subclasses (int, float, str)"
+        raise ValueError(exception_message) from None
+
+type_safe_raise_exception = Type_Safe__Raise_Exception()

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Validation.py

@@ -270,11 +270,11 @@ class Type_Safe__Validation:
     def validate_if_value_has_been_set(self, _self, annotations, name, value):
         if hasattr(_self, name) and annotations.get(name) :     # don't allow previously set variables to be set to None
             if getattr(_self, name) is not None:                         # unless it is already set to None
-                raise ValueError(f"Can't set None, to a variable that is already set. Invalid type for attribute '{name}'. Expected '{_self.__annotations__.get(name)}' but got '{type(value)}'")
+                raise ValueError(f"On {_self.__class__.__name__}, can't be set to None, to a variable that is already set. Invalid type for attribute '{name}'. Expected '{_self.__annotations__.get(name)}' but got '{type(value)}'")
 
-    def validate_if__types_are_compatible_for_assigment(self, name, current_type, expected_type):
+    def validate_if__types_are_compatible_for_assigment(self, _self, name, current_type, expected_type):
         if not type_safe_validation.are_types_compatible_for_assigment(current_type, expected_type):
-            type_safe_raise_exception.type_mismatch_error(name, expected_type, current_type)
+            type_safe_raise_exception.type_mismatch_error__on_instance(_self, name, expected_type, current_type)
 
     def validate_type_compatibility(self, target      : Any             ,             # Target object to validate
                                           annotations : Dict[str, Any]  ,             # Type annotations
@@ -295,7 +295,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}'") from None
+            raise ValueError(f"On {target.__class__.__name__}, 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
@@ -321,8 +321,8 @@ class Type_Safe__Validation:
     #                     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
+    def validate_variable_type(self, base_cls, var_name, var_type, var_value):                                # Validate type compatibility
         if type(var_type) is type and not isinstance(var_value, var_type):
-            type_safe_raise_exception.type_mismatch_error(var_name, var_type, type(var_value))
+            type_safe_raise_exception.type_mismatch_error__on_type(base_cls, var_name, var_type, type(var_value))
 
 type_safe_validation = Type_Safe__Validation()

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Class_Kwargs.py

@@ -96,7 +96,7 @@ class Type_Safe__Step__Class_Kwargs:
                 # If conversion fails, let the original validation handle it
                 pass
 
-        type_safe_validation.validate_variable_type(var_name, var_type, var_value)
+        type_safe_validation.validate_variable_type(base_cls, var_name, var_type, var_value)
         type_safe_validation.validate_type_immutability(var_name, var_type)
 
     def process_annotation(self, cls      : Type           ,                            # Process single annotation

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/osbot_utils/type_safe/type_safe_core/steps/Type_Safe__Step__Set_Attr.py

@@ -22,7 +22,7 @@ class Type_Safe__Step__Set_Attr:
         else:
             value = self.resolve_value__from_origin(value)
 
-        self.validate_literal_value(annotations, name, value)                            # Check Literal value constraints before generic type checking
+        self.validate_literal_value(_self, annotations, name, value)                            # Check Literal value constraints before generic type checking
 
         type_safe_validation.validate_type_compatibility(_self, annotations, name, value)
         return value
@@ -106,7 +106,7 @@ class Type_Safe__Step__Set_Attr:
         if name in immutable_vars:
             expected_type = immutable_vars[name]
             current_type  = type if value is type else type(value)
-            type_safe_validation.validate_if__types_are_compatible_for_assigment(name, current_type, expected_type)
+            type_safe_validation.validate_if__types_are_compatible_for_assigment(_self, name, current_type, expected_type)
             _super.__setattr__(name, value)
             return True
         return False
@@ -129,7 +129,7 @@ class Type_Safe__Step__Set_Attr:
 
         _super.__setattr__(name, value)
 
-    def validate_literal_value(self, annotations, name, value):     # Check if a value is valid for a Literal type annotation
+    def validate_literal_value(self, _self, annotations, name, value):     # Check if a value is valid for a Literal type annotation
 
         annotation = annotations.get(name)
         if not annotation:
@@ -145,7 +145,7 @@ class Type_Safe__Step__Set_Attr:
                         allowed_values = get_args(arg)                          # Found Literal inside Optional
                         if value is not None and value not in allowed_values:
                             allowed_str = ', '.join(repr(v) for v in allowed_values)
-                            raise ValueError(f"Invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
+                            raise ValueError(f"On {_self.__class__.__name__}, invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
                         return
 
 
@@ -153,7 +153,7 @@ class Type_Safe__Step__Set_Attr:
             allowed_values = get_args(annotation)
             if value not in allowed_values:
                 allowed_str = ', '.join(repr(v) for v in allowed_values)
-                raise ValueError(f"Invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
+                raise ValueError(f"On {_self.__class__.__name__}, invalid value for '{name}': must be one of [{allowed_str}], got {repr(value)}")
 
 
 type_safe_step_set_attr = Type_Safe__Step__Set_Attr()

osbot_utils-2.88.0/osbot_utils/version

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

{osbot_utils-2.87.0 → osbot_utils-2.88.0}/pyproject.toml

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

osbot_utils-2.87.0/osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Raise_Exception.py

@@ -1,14 +0,0 @@
-from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
-
-
-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) 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}' and the following subclasses (int, float, str)"
-        raise ValueError(exception_message) from None
-
-type_safe_raise_exception = Type_Safe__Raise_Exception()

osbot_utils-2.87.0/osbot_utils/version

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