osbot-utils 2.64.0__py3-none-any.whl → 2.65.0__py3-none-any.whl

osbot_utils/type_safe/Type_Safe__Method.py

@@ -10,12 +10,13 @@ class Type_Safe__Method:
         self.func         = func                                                          # Store original function
         self.sig          = inspect.signature(func)                                       # Get function signature
         self.annotations  = func.__annotations__                                          # Get function annotations
+        self.params       = list(self.sig.parameters.keys())
 
     def check_for_any_use(self):
         for param_name, type_hint in self.annotations.items():
             if type_hint is any:  # Detect incorrect usage of lowercase any
                 raise ValueError(f"Parameter '{param_name}' uses lowercase 'any' instead of 'Any' from typing module. "
-                              f"Please use 'from typing import Any' and annotate as '{param_name}: Any'")
+                                f"Please use 'from typing import Any' and annotate as '{param_name}: Any'")
 
     def handle_type_safety(self, args: tuple, kwargs: dict):                              # Main method to handle type safety
         self.check_for_any_use()
@@ -80,10 +81,6 @@ class Type_Safe__Method:
             self.validate_union_type(param_name, param_value, expected_type)             # Validate union
             return                                                                       # Exit early
 
-        # if self.try_basic_type_conversion(param_value, expected_type, param_name,        # Try basic type conversion
-        #                                 bound_args):                                     # Pass bound args
-        #    return                                                                       # Exit if conversion successful
-
         self.validate_direct_type(param_name, param_value, expected_type)                # Direct type validation
 
     def is_optional_type(self, type_hint: Any) -> bool:                                  # Check if type is Optional
@@ -108,9 +105,13 @@ class Type_Safe__Method:
         if not isinstance(param_value, list):                                         # Check if value is a list
             raise ValueError(f"Parameter '{param_name}' expected a list but got {type(param_value)}")  # Raise error if not list
 
-        item_type = get_args(expected_type)[0]                                        # Get list item type
-        for i, item in enumerate(param_value):                                        # Check each list item
-            if not isinstance(item, item_type):                                       # Validate item type
+        item_type = get_args(expected_type)[0]                                          # Get list item type
+        if get_origin(item_type) is not None:                                           # Handle the case when item_type is a subscripted type (which is not supported at the moment)
+            raise NotImplementedError(f"Validation for list items with subscripted type"
+                                      f" '{item_type}' is not yet supported "
+                                      f"in parameter '{param_name}'.")                  # todo: add support for checking for subscripted types
+        for i, item in enumerate(param_value):                                          # Check each list item
+            if not isinstance(item, item_type):                                         # Validate item type
                 raise ValueError(f"List item at index {i} expected type {item_type}, but got {type(item)}")  # Raise error for invalid item
 
     def validate_type_parameter(self, param_name: str, param_value: Any, expected_type: Any):           # Validate a Type[T] parameter
@@ -163,6 +164,7 @@ class Type_Safe__Method:
             is_optional = self.is_optional_type(expected_type)                            # Check if type is optional
             has_default = self.has_default_value(param_name)                              # Check if has default value
             self.validate_none_value(param_name, is_optional, has_default)                # Validate None value
+            return True
 
         origin = get_origin(expected_type)
 
@@ -174,11 +176,20 @@ class Type_Safe__Method:
                 if not isinstance(param_value, dict):
                     raise ValueError(f"Parameter '{param_name}' expected dict but got {type(param_value)}")
                 key_type, value_type = get_args(expected_type)
+                if value_type is Any:                                                                       # if value type is Any, we don't need to do any checks since they will all match
+                    return True
                 for k, v in param_value.items():
-                    if not isinstance(k, key_type):
-                        raise ValueError(f"Dict key '{k}' expected type {key_type}, but got {type(k)}")
-                    if not isinstance(v, value_type):
-                        raise ValueError(f"Dict value for key '{k}' expected type {value_type}, but got {type(v)}")
+                    if get_origin(key_type) is None:
+                        if not isinstance(k, key_type):
+                            raise ValueError(f"Dict key '{k}' expected type {key_type}, but got {type(k)}")
+                    else:
+                        raise NotImplementedError(f"Validation for subscripted key type '{key_type}' not yet supported in parameter '{param_name}'")
+
+                    if get_origin(value_type) is None:
+                        if not isinstance(v, value_type):
+                            raise ValueError(f"Dict value for key '{k}' expected type {value_type}, but got {type(v)}")
+                    elif value_type is not Any:
+                        raise NotImplementedError(f"Validation for subscripted value type '{value_type}' not yet supported in parameter '{param_name}'")
                 return True
             base_type = origin
         else:

osbot_utils/type_safe/decorators/type_safe.py

@@ -1,12 +1,20 @@
 import functools                                                                           # For wrapping functions
 from osbot_utils.type_safe.Type_Safe__Method import Type_Safe__Method
 
-def type_safe(func):                                                                       # Main decorator function
+def type_safe(func):                                                                        # Main decorator function
+    type_checker = Type_Safe__Method(func)  # Create type checker instance
+
+    has_only_self    = len(type_checker.params) == 1 and type_checker.params[0] == 'self'   # Check if method has only 'self' parameter or no parameters
+    has_no_params    = len(type_checker.params) == 0
+    direct_execution = has_no_params or has_only_self                                       # these are major performance optimisation where this @type_safe had an overhead of 250x (even on methods with no params) to now having an over head of ~5x
+
     @functools.wraps(func)                                                                 # Preserve function metadata
     def wrapper(*args, **kwargs):                                                          # Wrapper function
-        type_checker = Type_Safe__Method(func)                                              # Create type checker instance
-        bound_args   = type_checker.handle_type_safety(args, kwargs)                       # Validate type safety
-        return func(**bound_args.arguments)                                                # Call original function
+        if direct_execution:
+            return func(*args, **kwargs)
+        else:
+            bound_args   = type_checker.handle_type_safety(args, kwargs)                       # Validate type safety
+            return func(**bound_args.arguments)                                                # Call original function
 
     return wrapper                                                                         # Return wrapped function
 

osbot_utils/version

@@ -1 +1 @@
-v2.64.0
+v2.65.0

{osbot_utils-2.64.0.dist-info → osbot_utils-2.65.0.dist-info}/METADATA

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

@@ -374,13 +374,13 @@ osbot_utils/type_safe/Type_Safe.py,sha256=LOWRGOGpnRU2iTRLP47vUoyalK0vjFrWlnaghB
 osbot_utils/type_safe/Type_Safe__Base.py,sha256=UTMipTL6mXoetAEUCI5hs8RqXp4NDYOvoAiYoFOt5jg,8807
 osbot_utils/type_safe/Type_Safe__Dict.py,sha256=QB200L5eNWT3FnUv8sm5kncj1wXJsJ9uRycNFl9xb6Y,3077
 osbot_utils/type_safe/Type_Safe__List.py,sha256=y_lp7Ai0HfQCqC8Bxn0g6_M9MP5lPOXy5Dhkuj2fJvQ,1891
-osbot_utils/type_safe/Type_Safe__Method.py,sha256=lHBCpW5nf2ikybm9oucvq6L67VXNO4qEvzGskJ1hGHs,15697
+osbot_utils/type_safe/Type_Safe__Method.py,sha256=cvFYoR42SPU4qQPG45CCHQw7i-sq7R6gHECcsncGGL4,16653
 osbot_utils/type_safe/Type_Safe__Primitive.py,sha256=CJ4LP2W5i9utSSzuiiJrwqvwdMv1DeQ6dIZICtYfLTY,3635
 osbot_utils/type_safe/Type_Safe__Set.py,sha256=j12fc8cbd9-s_a13ysaz723rNEW4Dt6hObCd0S-AjIg,1432
 osbot_utils/type_safe/Type_Safe__Tuple.py,sha256=Kx7C4YfHybRbMmVMcmV6yFLi4T48pb592vEZfjjyLxo,1710
 osbot_utils/type_safe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/type_safe/decorators/type_safe.py,sha256=ERFfJuAIo5qLp03YEDu2zu5wxu65OhR7hOybwuTfLlc,1006
+osbot_utils/type_safe/decorators/type_safe.py,sha256=pghmcxZp-L3E3yQMSPOyC-inVO1KU1aql_naEqWLt-8,1507
 osbot_utils/type_safe/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/methods/type_safe_property.py,sha256=DcJkOIs6swJtkglsZVKLyFSczCGSJISOVwAmvjCOQvo,1425
 osbot_utils/type_safe/shared/Type_Safe__Annotations.py,sha256=nmVqCbhk4kUYrw_mdYqugxQlv4gM3NUUH89FYTHUg-c,1133
@@ -432,8 +432,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=Ik_Z1_68qStKaUrjNMdT-_2K34-svwqhzWn_iKWEiAM,8
-osbot_utils-2.64.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.64.0.dist-info/METADATA,sha256=NVqO8V4OXl0l6YXdNQCbsspZ4wle5_jgH97qimTST9M,1329
-osbot_utils-2.64.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.64.0.dist-info/RECORD,,
+osbot_utils/version,sha256=oCkmaExem5YihngZUO4qUVW6DPLlhdxUDeJF0raydEg,8
+osbot_utils-2.65.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.65.0.dist-info/METADATA,sha256=kWWFHflY8D1c-M9vqnraZaziAIrgTpG9r8teABngWrY,1329
+osbot_utils-2.65.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.65.0.dist-info/RECORD,,