osbot-utils 1.31.0__tar.gz → 1.32.0__tar.gz

{osbot_utils-1.31.0 → osbot_utils-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.31.0
+Version: 1.32.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -22,7 +22,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-v1.31.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.32.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-1.31.0 → osbot_utils-1.32.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-v1.31.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.32.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-1.32.0/osbot_utils/base_classes/Kwargs_To_Self.py

@@ -0,0 +1,4 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+
+# todo: refactor all of Kwargs_To_Self to use Type_Safe
+Kwargs_To_Self = Type_Safe

osbot_utils-1.31.0/osbot_utils/base_classes/Kwargs_To_Self.py → osbot_utils-1.32.0/osbot_utils/base_classes/Type_Safe.py

@@ -13,9 +13,10 @@ from osbot_utils.base_classes.Type_Safe__List   import Type_Safe__List
 from osbot_utils.utils.Dev                      import pprint
 from osbot_utils.utils.Json                     import json_parse
 from osbot_utils.utils.Misc                     import list_set
-from osbot_utils.utils.Objects                  import default_value, value_type_matches_obj_annotation_for_attr, \
+from osbot_utils.utils.Objects import default_value, value_type_matches_obj_annotation_for_attr, \
     raise_exception_on_obj_type_annotation_mismatch, obj_is_attribute_annotation_of_type, enum_from_value, \
-    obj_is_type_union_compatible, value_type_matches_obj_annotation_for_union_attr
+    obj_is_type_union_compatible, value_type_matches_obj_annotation_for_union_attr, \
+    convert_dict_to_value_from_obj_annotation
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):
@@ -47,7 +48,7 @@ immutable_types = (bool, int, float, complex, str, tuple, frozenset, bytes, None
 #      for example if we have an method like def add_node(self, title: str, call_index: int):
 #          throw an exception if the type of the value passed in is not the same as the one defined in the method
 
-class Kwargs_To_Self:
+class Type_Safe:
 
     def __init__(self, **kwargs):
         """
@@ -82,8 +83,8 @@ class Kwargs_To_Self:
                 if value is not None:                                   # prevent None values from overwriting existing values, which is quite common in default constructors
                     setattr(self, key, value)
             else:
-                raise Exception(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")
+                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")
 
     def __enter__(self): return self
     def __exit__(self, exc_type, exc_val, exc_tb): pass
@@ -92,23 +93,19 @@ class Kwargs_To_Self:
         if not hasattr(self, '__annotations__'):                    # can't do type safety checks if the class does not have annotations
             return super().__setattr__(name, value)
 
-            # if self.__type_safety__:
-        #     if self.__lock_attributes__:
-            # todo: this can't work on all, current hypothesis is that this will work for the values that are explicitly set
-            # if not hasattr(self, name):
-            #     raise AttributeError(f"'[Object Locked] Current object is locked (with __lock_attributes__=True) which prevents new attributes allocations (i.e. setattr calls). In this case  {type(self).__name__}' object has no attribute '{name}'") from None
-
         if value is not None:
+            if type(value) is dict:
+                value = convert_dict_to_value_from_obj_annotation(self, name, value)
             check_1 = value_type_matches_obj_annotation_for_attr      (self, name, value)
             check_2 = value_type_matches_obj_annotation_for_union_attr(self, name, value)
             if (check_1 is False and check_2 is None  or
                 check_1 is None  and check_2 is False or
                 check_1 is False and check_2 is False   ):          # fix for type safety assigment on Union vars
-                raise Exception(f"Invalid type for attribute '{name}'. Expected '{self.__annotations__.get(name)}' but got '{type(value)}'")
+                raise ValueError(f"Invalid type for attribute '{name}'. Expected '{self.__annotations__.get(name)}' but got '{type(value)}'")
         else:
             if hasattr(self, name) and self.__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 Exception(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"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)}'")
 
         super().__setattr__(name, value)
 
@@ -145,13 +142,13 @@ class Kwargs_To_Self:
                         if var_value is not None:                                                                   # allow None assignments on ctor since that is a valid use case
                             if var_type and not isinstance(var_value, var_type):                                    # check type
                                 exception_message = f"variable '{var_name}' is defined as type '{var_type}' but has value '{var_value}' of type '{type(var_value)}'"
-                                raise Exception(exception_message)
+                                raise ValueError(exception_message)
                             if var_type not in immutable_types and var_name.startswith('__') is False:              # if var_type is not one of the immutable_types or is an __ internal
                                 #todo: fix type safety bug that I believe is caused here
                                 if obj_is_type_union_compatible(var_type, immutable_types) is False:                # if var_type is not something like Optional[Union[int, str]]
                                     if type(var_type) not in immutable_types:
                                         exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Kwargs_To_Self, with only the following immutable types being supported: '{immutable_types}'"
-                                        raise Exception(exception_message)
+                                        raise ValueError(exception_message)
             if include_base_classes is False:
                 break
         return kwargs
@@ -251,14 +248,14 @@ class Kwargs_To_Self:
             if value is not None:
                 if hasattr(self,'__annotations__'):  # can only do type safety checks if the class does not have annotations
                     if value_type_matches_obj_annotation_for_attr(self, key, value) is False:
-                        raise Exception(f"Invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
+                        raise ValueError(f"Invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
                 setattr(self, key, value)
         return self
 
 
     def deserialize_from_dict(self, data):
         for key, value in data.items():
-            if hasattr(self, key) and isinstance(getattr(self, key), Kwargs_To_Self):
+            if hasattr(self, key) and isinstance(getattr(self, key), Type_Safe):
                 getattr(self, key).deserialize_from_dict(value)                         # Recursive call for complex nested objects
             else:
                 if hasattr(self, '__annotations__'):  # can only do type safety checks if the class does not have annotations

{osbot_utils-1.31.0 → osbot_utils-1.32.0}/osbot_utils/testing/Catch.py

@@ -42,7 +42,7 @@ class Catch:
         if self.expected_error:
             self.assert_error_is(self.expected_error)
         if self.expect_exception and exception_type is None:
-            raise Exception(f'Expected exception: {self.expected_error} but no exception was raised')
+            raise ValueError(f'Expected exception: {self.expected_error} but no exception was raised')
         if self.catch_exception:
             return True     # returning true here will prevent the exception to be propagated (which is the objective of this class :) )
         return False

{osbot_utils-1.31.0 → osbot_utils-1.32.0}/osbot_utils/utils/Objects.py

@@ -69,6 +69,9 @@ def base_classes(cls):
         target = type(cls)
     return type_base_classes(target)
 
+def base_classes_names(cls):
+    return [cls.__name__ for cls in base_classes(cls)]
+
 def class_functions_names(target):
     return list_set(class_functions(target))
 
@@ -89,6 +92,17 @@ def class_full_name(target):
         type_name   = type_target.__name__
         return f'{type_module}.{type_name}'
 
+def convert_dict_to_value_from_obj_annotation(target, attr_name, value):
+    if target is not None and attr_name is not None:
+        if hasattr(target, '__annotations__'):
+            obj_annotations  = target.__annotations__
+            if hasattr(obj_annotations,'get'):
+                attribute_annotation = obj_annotations.get(attr_name)
+                if 'Type_Safe' in base_classes_names(attribute_annotation):
+                    return attribute_annotation(**value)
+    return value
+
+
 def default_value(target : type):
     try:
         return target()                 #  try to create the object using the default constructor

osbot_utils-1.32.0/osbot_utils/version

@@ -0,0 +1 @@
+v1.32.0

{osbot_utils-1.31.0 → osbot_utils-1.32.0}/pyproject.toml

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

osbot_utils-1.31.0/osbot_utils/base_classes/Type_Safe.py

@@ -1,6 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-# todo: refactor all of Kwargs_To_Self into this class (in a way to minimize the side effects, since
-#        Kwargs_To_Self is used in many places in the codebase)
-
-Type_Safe = Kwargs_To_Self

osbot_utils-1.31.0/osbot_utils/version

@@ -1 +0,0 @@
-v1.31.0