Merge pull request #105 from gridsmartercities/transform

Added ability to transform an extracted value before validating it.

Author: zoltax

README.md

@@ -242,6 +242,49 @@ def extract_dictionary_example(a_dictionary, **kwargs):
     """
     return kwargs  # returns {'my_param_1': 'Hello!', 'my_param_2': 'Bye!'}
 
+```
+
+You can apply a transformation to an extracted value. The transformation will happen before validation.
+
+Example:
+```python
+@extract(parameters=[
+    Parameter(path='/params/my_param', func_param_name='a_dictionary', transform=int)  # extracts a non mandatory my_param from a_dictionary
+])
+def extract_with_transform_example(a_dictionary, my_param=None):
+    """
+        a_dictionary = { 
+            'params': {
+                'my_param_1': '2'  # the original value is the string '2'
+            }
+        }
+    """
+    return my_param  # returns the int value 2
+
+```
+
+The transform function can be any function, with its own error handling.
+
+Example:
+```python
+
+def to_int(arg):
+    try:
+        return int(arg)
+    except Exception:
+        raise Exception("My custom error message")
+
+@extract(parameters=[
+    Parameter(path='/params/my_param', func_param_name='a_dictionary', transform=to_int)  # extracts a non mandatory my_param from a_dictionary
+])
+def extract_with_custom_transform_example(a_dictionary, my_param=None):
+    return {}
+    
+response = extract_with_custom_transform_example({'params': {'my_param': 'abc'}})
+
+print(response)  # prints {'statusCode': 400, 'body': '{"message": "Error extracting parameters"}'}, and the logs will contain the "My custom error message" message.
+
+
 ```
 
 ### extract_from_event

aws_lambda_decorators/classes.py

@@ -130,7 +130,7 @@ def validate(self, value, group_errors):
 class Parameter(ValidatedParameter, BaseParameter):
     """Class used to encapsulate the extract methods parameter data."""
 
-    def __init__(self, path="", func_param_name=None, validators=None, var_name=None, default=None):  # noqa: pylint - too-many-arguments
+    def __init__(self, path="", func_param_name=None, validators=None, var_name=None, default=None, transform=None):  # noqa: pylint - too-many-arguments
         """
         Sets the private variables of the Parameter object.
 
@@ -154,9 +154,11 @@ def fun(event, context). To extract from context func_param_name has to be "cont
                 value is the last element of the path (e.g. "c" in the case above)
             default (any): Optional, a default value if the value is missing and not mandatory.
                 The default value is None
+            transform (function): Optional, a function to apply to the extracted value before checking validation rules.
         """
         self._path = path
         self._default = default
+        self._transform = transform
         ValidatedParameter.__init__(self, func_param_name, validators)
         BaseParameter.__init__(self, var_name)
 
@@ -187,6 +189,9 @@ def extract_value(self, dict_value):
         if not self._name:
             self._name = real_key
 
+        if dict_value and self._transform:
+            dict_value = self._transform(dict_value)
+
         return dict_value
 
     def validate_path(self, value, group_errors=False):

setup.py

@@ -3,7 +3,7 @@
 LONG_DESCRIPTION = open("README.md").read()
 
 setup(name="aws-lambda-decorators",
-      version="0.44",
+      version="0.45",
       description="A set of python decorators to simplify aws python lambda development",
       long_description=LONG_DESCRIPTION,
       long_description_content_type="text/markdown",

tests/test_decorators.py

@@ -1679,6 +1679,91 @@ def handler(event, a=None):  # noqa: pylint - unused-argument
         response = handler(event)
         self.assertEqual(None, response)
 
+    def test_can_apply_transformation(self):
+        event = {
+            "a": "2"
+        }
+
+        @extract([Parameter("/a", "event", transform=float)])
+        def handler(event, a=None):  # noqa: pylint - unused-argument
+            return a
+
+        response = handler(event)
+        self.assertEqual(2, response)
+
+    def test_apply_transformation_on_none_value(self):
+        event = {
+            "a": None
+        }
+
+        @extract([Parameter("/a", "event", transform=float)])
+        def handler(event, a=None):  # noqa: pylint - unused-argument
+            return a
+
+        response = handler(event)
+        self.assertEqual(None, response)
+
+    def test_apply_custom_transformation(self):
+        event = {
+            "a": "2"
+        }
+
+        def to_float(arg):
+            return float(arg)
+
+        @extract([Parameter("/a", "event", transform=to_float)])
+        def handler(event, a=None):  # noqa: pylint - unused-argument
+            return a
+
+        response = handler(event)
+        self.assertEqual(2, response)
+
+    @patch("aws_lambda_decorators.decorators.LOGGER")
+    def test_apply_custom_transformation_with_error_handling(self, mock_logger):
+        event = {
+            "a": "abc"
+        }
+
+        def to_float(arg):
+            try:
+                return float(arg)
+            except Exception:
+                raise Exception(f"Custom error message: value '{arg}' cannot be converted to float")
+
+        @extract([Parameter("/a", "event", transform=to_float)])
+        def handler(event, a=None):  # noqa: pylint - unused-argument
+            return {}
+
+        response = handler(event)
+        self.assertEqual(400, response["statusCode"])
+        self.assertEqual("{\"message\": \"Error extracting parameters\"}", response["body"])
+
+        mock_logger.error.assert_called_once_with("%s: %s in argument %s for path %s",
+                                                  "Exception",
+                                                  "Custom error message: value 'abc' cannot be converted to float",
+                                                  "event",
+                                                  "/a")
+
+    @patch("aws_lambda_decorators.decorators.LOGGER")
+    def test_apply_invalid_transformation_raises_error(self, mock_logger):
+        event = {
+            "a": "abc"
+        }
+
+        @extract([Parameter("/a", "event", transform=float)])
+        def handler(event, a=None):  # noqa: pylint - unused-argument
+            return {}
+
+        response = handler(event)
+        self.assertEqual(400, response["statusCode"])
+        self.assertEqual("{\"message\": \"Error extracting parameters\"}", response["body"])
+
+        mock_logger.error.assert_called_once_with("%s: %s in argument %s for path %s",
+                                                  "ValueError",
+                                                  "could not convert string to float: 'abc'",
+                                                  "event",
+                                                  "/a")
+
 
 class IsolatedDecoderTests(unittest.TestCase):
     # Tests have been named so they run in a specific order