osbot-utils 1.76.0__py3-none-any.whl → 1.78.0__py3-none-any.whl

osbot_utils/base_classes/Type_Safe.py

@@ -20,7 +20,8 @@ from osbot_utils.utils.Misc                     import list_set
 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, \
-    convert_dict_to_value_from_obj_annotation, dict_to_obj, convert_to_value_from_obj_annotation
+    convert_dict_to_value_from_obj_annotation, dict_to_obj, convert_to_value_from_obj_annotation, \
+    obj_attribute_annotation
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -290,6 +291,14 @@ class Type_Safe:
                             continue
                     if obj_is_attribute_annotation_of_type(self, key, dict):                                # handle the case when the value is a dict
                         value = self.deserialize_dict__using_key_value_annotations(key, value)
+                    elif obj_is_attribute_annotation_of_type(self, key, list):                              # handle the case when the value is a list
+                        attribute_annotation = obj_attribute_annotation(self, key)                          # get the annotation for this variable
+                        expected_type        = get_args(attribute_annotation)[0]                            # get the first arg (which is the type)
+                        type_safe_list       = Type_Safe__List(expected_type)                               # create a new instance of Type_Safe__List
+                        for item in value:                                                                  # next we need to convert all items (to make sure they all match the type)
+                            new_item = expected_type(**item)                                                # create new object
+                            type_safe_list.append(new_item)                                                 # and add it to the new type_safe_list obejct
+                        value = type_safe_list                                                              # todo: refactor out this create list code, maybe to an deserialize_from_list method
                     else:
                         if value is not None:
                             if obj_is_attribute_annotation_of_type(self, key, EnumMeta):            # Handle the case when the value is an Enum

osbot_utils/base_classes/Type_Safe__List.py

@@ -1,3 +1,7 @@
+from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+
+EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
+
 class Type_Safe__List(list):
 
     def __init__(self, expected_type, *args):
@@ -5,10 +9,125 @@ class Type_Safe__List(list):
         self.expected_type = expected_type
 
     def __repr__(self):
-        return f"list[{self.expected_type.__name__}] with {len(self)} elements"
+        expected_type_name = type_str(self.expected_type)
+        return f"list[{expected_type_name}] with {len(self)} elements"
 
     def append(self, item):
-        if not isinstance(item, self.expected_type):
-            raise TypeError(f"In Type_Safe__List: Invalid type for item: Expected '{self.expected_type.__name__}', but got '{type(item).__name__}'")
+        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}")
         super().append(item)
 
+    def is_instance_of_type(self, item, expected_type):
+        if expected_type is Any:
+            return True
+        if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
+            return True
+        origin = get_origin(expected_type)
+        args   = get_args(expected_type)
+        if origin is None:
+            if expected_type in EXACT_TYPE_MATCH:
+                if type(item) is expected_type:
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            else:
+                if isinstance(item, expected_type):                                 # Non-parameterized type
+                    return True
+                else:
+                    expected_type_name = type_str(expected_type)
+                    actual_type_name   = type_str(type(item))
+                    raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+        elif origin is list and args:                                                    # Expected type is List[...]
+            (item_type,) = args
+            if not isinstance(item, list):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for idx, elem in enumerate(item):
+                try:
+                    self.is_instance_of_type(elem, item_type)
+                except TypeError as e:
+                    raise TypeError(f"In list at index {idx}: {e}")
+            return True
+        elif origin is dict and args:                                                    # Expected type is Dict[...]
+            key_type, value_type = args
+            if not isinstance(item, dict):
+                expected_type_name = type_str(expected_type)
+                actual_type_name   = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            for k, v in item.items():
+                try:
+                    self.is_instance_of_type(k, key_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict key '{k}': {e}")
+                try:
+                    self.is_instance_of_type(v, value_type)
+                except TypeError as e:
+                    raise TypeError(f"In dict value for key '{k}': {e}")
+            return True
+        elif origin is tuple:
+            if not isinstance(item, tuple):
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+            if len(args) != len(item):
+                raise TypeError(f"Expected tuple of length {len(args)}, but got {len(item)}")
+            for idx, (elem, elem_type) in enumerate(zip(item, args)):
+                try:
+                    self.is_instance_of_type(elem, elem_type)
+                except TypeError as e:
+                    raise TypeError(f"In tuple at index {idx}: {e}")
+            return True
+        elif origin is Union or expected_type is Optional:                                                   # Expected type is Union[...]
+            for arg in args:
+                try:
+                    self.is_instance_of_type(item, arg)
+                    return True
+                except TypeError:
+                    continue
+            expected_type_name = type_str(expected_type)
+            actual_type_name   = type_str(type(item))
+            raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+        else:
+            if isinstance(item, origin):
+                return True
+            else:
+                expected_type_name = type_str(expected_type)
+                actual_type_name = type_str(type(item))
+                raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
+
+# todo: see if we should/can move this to the Objects.py file
+def type_str(tp):
+    origin = get_origin(tp)
+    if origin is None:
+        if hasattr(tp, '__name__'):
+            return tp.__name__
+        else:
+            return str(tp)
+    else:
+        args = get_args(tp)
+        args_str = ', '.join(type_str(arg) for arg in args)
+        return f"{origin.__name__}[{args_str}]"
+
+def get_object_type_str(obj):
+    if isinstance(obj, dict):
+        if not obj:
+            return "Dict[Empty]"
+        key_types      = set(type(k).__name__ for k in obj.keys())
+        value_types    = set(type(v).__name__ for v in obj.values())
+        key_type_str   = ', '.join(sorted(key_types))
+        value_type_str = ', '.join(sorted(value_types))
+        return f"Dict[{key_type_str}, {value_type_str}]"
+    elif isinstance(obj, list):
+        if not obj:
+            return "List[Empty]"
+        elem_types = set(type(e).__name__ for e in obj)
+        elem_type_str = ', '.join(sorted(elem_types))
+        return f"List[{elem_type_str}]"
+    else:
+        return type(obj).__name__

osbot_utils/utils/Objects.py

@@ -394,6 +394,12 @@ def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
             attr_type        = obj_annotations.get(attr_name)
             if attr_type:
                 origin_attr_type = get_origin(attr_type)                # to handle when type definion contains an generic
+                if origin_attr_type is typing.Union:
+                    args = get_args(attr_type)
+                    if len(args)==2 and args[1] is type(None):          # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (whcih is an shorthand for Union[X, None] )
+                        attr_type = args[0]
+                        origin_attr_type = get_origin(attr_type)
+
                 if origin_attr_type:
                     attr_type = origin_attr_type
                 value_type = type(value)

osbot_utils/version

@@ -1 +1 @@
-v1.76.0
+v1.78.0

{osbot_utils-1.76.0.dist-info → osbot_utils-1.78.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.76.0
+Version: 1.78.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -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-v1.76.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.78.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.76.0.dist-info → osbot_utils-1.78.0.dist-info}/RECORD

@@ -2,8 +2,8 @@ osbot_utils/__init__.py,sha256=DdJDmQc9zbQUlPVyTJOww6Ixrn9n4bD3ami5ItQfzJI,16
 osbot_utils/base_classes/Cache_Pickle.py,sha256=kPCwrgUbf_dEdxUz7vW1GuvIPwlNXxuRhb-H3AbSpII,5884
 osbot_utils/base_classes/Kwargs_To_Disk.py,sha256=HHoy05NC_w35WcT-OnSKoSIV_cLqaU9rdjH0_KNTM0E,1096
 osbot_utils/base_classes/Kwargs_To_Self.py,sha256=weFNsBfBNV9W_qBkN-IdBD4yYcJV_zgTxBRO-ZlcPS4,141
-osbot_utils/base_classes/Type_Safe.py,sha256=HFCSsZzPaLWXsdHwbZnlSXiSQkgUz7-zlSKsZdz4rb8,20723
-osbot_utils/base_classes/Type_Safe__List.py,sha256=-80C9OhsK6iDR2dAG8yNLAZV0qg5x3faqvSUigFCMJw,517
+osbot_utils/base_classes/Type_Safe.py,sha256=3RnP8MRlwVXdMd0hZBUPM0xQULUo5s4BoWDc4s5VKQ4,22010
+osbot_utils/base_classes/Type_Safe__List.py,sha256=iWyoc2xjHkTJrZTVnPse9Rljte2tF67oNq8yA7jnAhY,5996
 osbot_utils/base_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/context_managers/async_invoke.py,sha256=-ja3K8orLy8Of54CIYSK-zn443pOIDY2hnFBjVELrXc,829
@@ -294,7 +294,7 @@ osbot_utils/utils/Json.py,sha256=8fpYFXzNPSrwYfXMt3eGKpe-lhxh1kEaCRae1X1943A,666
 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=A8AzI1M912NDxNpPRrW1lPrwIIjVOoGUQHzyyRCEMFU,17102
-osbot_utils/utils/Objects.py,sha256=fqDy8AFimxkUxGAMQBkqYCvQnT_TDcR8EwHOMWPxorc,18992
+osbot_utils/utils/Objects.py,sha256=RiViT25vuh9zk_gveV2VzSKYg6vUaF2wwyAPPsj1qyw,19426
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=tx8N6wRKL3RDHboDRKZn8SirSJdSAE9cACyJkxrThZ8,12792
@@ -306,8 +306,8 @@ osbot_utils/utils/Toml.py,sha256=-_Yv5T8ZhGGoDSSoNEdFhSsXiK_JPjGkPijm4JoeHSk,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=Sh4I_vevwaIEdaWg7696h0OuGLhRGXbvbES7xCszDMg,8
-osbot_utils-1.76.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-1.76.0.dist-info/METADATA,sha256=e5XMnrg0uo8xBZX2txBVODepc-_JQX3oVD9srvPmSAc,1317
-osbot_utils-1.76.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-osbot_utils-1.76.0.dist-info/RECORD,,
+osbot_utils/version,sha256=iNZGWI4Q60T4H2HfKcEvHaXbPuwoOyLQAdfo28Caebg,8
+osbot_utils-1.78.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-1.78.0.dist-info/METADATA,sha256=Z9xFeZDq27qy4sfwSNZxHuVCf8YRb6bk8DvrL1s2lCA,1317
+osbot_utils-1.78.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+osbot_utils-1.78.0.dist-info/RECORD,,