Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.42.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.42.1-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/type_safe/type_safe_core/decorators/type_safe.py

@@ -5,21 +5,27 @@
 
 
 def type_safe(func):                                                                                # Main decorator function
-    type_checker = Type_Safe__Method(func)  # Create type checker instance
+    type_checker = Type_Safe__Method(func).setup()                                                  # Create type checker instance
     return_type  = func.__annotations__.get('return')
 
     validator        = Type_Safe__Base() if return_type else None
     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
+    has_var_keyword  = type_checker.var_keyword_param is not None                                   # Pre-calculate if we need to handle VAR_KEYWORD parameters (performance optimization)
+
 
     @functools.wraps(func)                                                                          # Preserve function metadata
     def wrapper(*args, **kwargs):                                                                   # Wrapper function
         if direct_execution:
             result =  func(*args, **kwargs)
         else:
             bound_args = type_checker.handle_type_safety(args, kwargs)                              # Validate type safety
-            result     =  func(**bound_args.arguments)                                              # Call original function
+            if has_var_keyword:                                                                     # Only call prepare_function_arguments if needed
+                regular_args, var_kwargs = type_checker.prepare_function_arguments(bound_args)
+                result = func(**regular_args, **var_kwargs)
+            else:
+                result = func(**bound_args.arguments)
 
         if return_type is not None and result is not None:                                          # Validate return type using existing type checking infrastructure
             if isinstance(return_type, type) and issubclass(return_type, Type_Safe__Primitive):     # Try to convert Type_Safe__Primitive types

osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py

@@ -10,10 +10,20 @@
 
 class Type_Safe__Method:                                                                  # Class to handle method type safety validation
     def __init__(self, func):                                                             # Initialize with function
-        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())
+        self.func              = func                                                          # Store original function
+        self.sig               = None                             # Get function signature
+        self.annotations       = None                             # Get function annotations
+        self.params            = None
+        self.var_keyword_param = None
+
+    def setup(self):
+        self.sig               = inspect.signature(self.func)                                       # Get function signature
+        self.annotations       = self.func.__annotations__                                          # Get function annotations
+        self.params            = list(self.sig.parameters.keys())
+        self.var_keyword_param = next((name for name, param in self.sig.parameters.items()          # Pre-calculate VAR_KEYWORD parameter name for performance optimization
+                                       if param.kind is inspect.Parameter.VAR_KEYWORD),
+                                       None)
+        return self
 
     def check_for_any_use(self):
         for param_name, type_hint in self.annotations.items():
@@ -72,6 +82,19 @@ def bind_args(self, args: tuple, kwargs: dict):
         bound_args.apply_defaults()                                                         # Apply default values
         return bound_args                                                                   # Return bound arguments
 
+    def prepare_function_arguments(self, bound_args):                                       # Prepare arguments for function call, handling VAR_KEYWORD parameters correctly
+
+        if self.var_keyword_param is None:
+            return bound_args.arguments, {}                                                           # Optimized path if no **kwargs
+
+        regular_args = {k: v for k, v in bound_args.arguments.items()
+                        if k != self.var_keyword_param}                                               # Exclude **kwargs param
+
+        var_kwargs   = bound_args.arguments.get(self.var_keyword_param, {})                           # Extract **kwargs
+
+        return regular_args, var_kwargs
+
+
     def validate_parameter(self, param_name: str, param_value: Any, bound_args):            # Validate a single parameter
         self.validate_immutable_parameter(param_name, param_value)                          # Validata the param_value (make sure if it set it is on of IMMUTABLE_TYPES)
         if param_name in self.annotations:                                                  # Check if parameter is annotated

osbot_utils/version

@@ -1 +1 @@
-v3.42.0
+v3.42.1

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v3.42.0"
+version     = "v3.42.1"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <[email protected]>"]
 license     = "MIT"

tests/unit/type_safe/type_safe_core/decorators/test__decorator__type_safe__bugs.py

@@ -63,27 +63,3 @@ def create_openapi_spec(servers: List[Dict[str, str]]):
 
 
 
-    def test__bug__kwargs_not_properly_returned_in_type_safe(self):
-
-        class Test_Class(Type_Safe):
-            @type_safe
-            def method_with_kwargs(self, name: str, **kwargs):          # The bug is caused by the non handling correctly of the **kwargs parameter
-                return {"name": name, "kwargs": kwargs}                 # We expect kwargs to contain all extra parameters
-
-        test_obj = Test_Class()
-        with self.assertRaises(ValueError) as context:                  # This works as expected - type safety catches the error
-            test_obj.method_with_kwargs(name=b'123')                    # Wrong type for 'name'
-
-        assert str(context.exception) == "Parameter 'name' expected type <class 'str'>, but got <class 'bytes'>"
-
-        result   = test_obj.method_with_kwargs(name="test", extra=True, another="value")
-        expected = {"kwargs": {"extra": True, "another": "value"},
-                    "name"  : "test",}
-        current =  {'kwargs': { "kwargs": {"extra": True, "another": "value"}},             # # BUG: there is an extra kwargs added to the return value
-                     "name" : "test",}
-
-        assert result != expected  # BUG: This is what we expect
-        assert result == current   # BUG: This is what we get
-
-
-

tests/unit/type_safe/type_safe_core/decorators/test__decorator__type_safe__performance.py

@@ -94,7 +94,7 @@ def with_check(self):
 #                    ) -> None:
 #             pass
 #
-#         checker = Type_Safe__Method(simple_func)
+#         checker = Type_Safe__Method(simple_func).setup()
 #
 #         # Measure validation time
 #         def validate():
@@ -118,7 +118,7 @@ def with_check(self):
 #                        ) -> None:
 #             pass
 #
-#         checker = Type_Safe__Method(complex_func)
+#         checker = Type_Safe__Method(complex_func).setup()
 #
 #         # Measure validation time with all parameters
 #         def validate():
@@ -143,7 +143,7 @@ def with_check(self):
 #         def list_func(items: List[int]) -> None:
 #             pass
 #
-#         checker = Type_Safe__Method(list_func)
+#         checker = Type_Safe__Method(list_func).setup()
 #
 #         for size in [10, 100, 1000]:
 #             test_list = list(range(size))
@@ -161,7 +161,7 @@ def with_check(self):
 #         def dict_func(data: Dict[str, int]) -> None:
 #             pass
 #
-#         checker = Type_Safe__Method(dict_func)
+#         checker = Type_Safe__Method(dict_func).setup()
 #
 #         for size in [10, 100, 1000]:
 #             test_dict = {f"key{i}": i for i in range(size)}

tests/unit/type_safe/type_safe_core/decorators/test__decorator__type_safe__regression.py

@@ -523,3 +523,51 @@ def return_self(self) -> 'An_Class':
         # with pytest.raises(TypeError, match=re.escape(error_message)):
         #     An_Class().return_self()              # BUG
         assert type(An_Class().return_self()) is An_Class           # FIXED
+
+    def test__regression__type_safe__decorator__params_value(self):
+
+        from osbot_utils.type_safe.type_safe_core.decorators.type_safe import type_safe
+
+        @type_safe
+        def an_method( **params):
+            return params
+
+        # assert an_method()     == {'params': {}}                # BUG
+        # assert an_method(a=42) == {'params': {'a': 42}}         # BUG
+        assert an_method()     == {}
+        assert an_method(a=42) == {'a': 42}
+
+        @type_safe
+        def an_method_2( **params_2):
+            return params_2
+
+        #assert an_method_2()     == {'params_2': {}}            # BUG
+        #assert an_method_2(a=42) == {'params_2': {'a': 42}}     # BUG
+
+        assert an_method_2()     == {}
+        assert an_method_2(a=42) == {'a': 42}
+
+
+    def test__regression__kwargs_not_properly_returned_in_type_safe(self):
+
+        class Test_Class(Type_Safe):
+            @type_safe
+            def method_with_kwargs(self, name: str, **kwargs):          # The bug is caused by the non handling correctly of the **kwargs parameter
+                return {"name": name, "kwargs": kwargs}                 # We expect kwargs to contain all extra parameters
+
+        test_obj = Test_Class()
+        with self.assertRaises(ValueError) as context:                  # This works as expected - type safety catches the error
+            test_obj.method_with_kwargs(name=b'123')                    # Wrong type for 'name'
+
+        assert str(context.exception) == "Parameter 'name' expected type <class 'str'>, but got <class 'bytes'>"
+
+        result   = test_obj.method_with_kwargs(name="test", extra=True, another="value")
+        expected = {"kwargs": {"extra": True, "another": "value"},
+                    "name"  : "test",}
+        with_bug = {'kwargs': { "kwargs": {"extra": True, "another": "value"}},             # # BUG: there is an extra kwargs added to the return value
+                     "name" : "test",}
+
+        # assert result != expected  # BUG: This is what we expect
+        # assert result == current   # BUG: This is what we get
+        assert result == expected
+        assert result != with_bug